+ // Check dottedness first so dummy indices will end up next to each other
+ if (dotted != o.dotted)
+ return dotted ? -1 : 1;
+
+ int cmpval = inherited::compare_same_type(other);
+ if (cmpval)
+ return cmpval;
+
+ return 0;
+}
+
+bool spinidx::match_same_type(const basic & other) const
+{
+ GINAC_ASSERT(is_a<spinidx>(other));
+ const spinidx &o = static_cast<const spinidx &>(other);
+
+ if (dotted != o.dotted)
+ return false;
+ return inherited::match_same_type(other);
+}
+
+unsigned idx::calchash() const
+{
+ // NOTE: The code in simplify_indexed() assumes that canonically
+ // ordered sequences of indices have the two members of dummy index
+ // pairs lying next to each other. The hash values for indices must
+ // be devised accordingly. The easiest (only?) way to guarantee the
+ // desired ordering is to make indices with the same value have equal
+ // hash keys. That is, the hash values must not depend on the index
+ // dimensions or other attributes (variance etc.).
+ // The compare_same_type() methods will take care of the rest.
+ unsigned v = golden_ratio_hash(tinfo());
+ v = rotate_left(v);
+ v ^= value.gethash();
+
+ // Store calculated hash value only if object is already evaluated
+ if (flags & status_flags::evaluated) {
+ setflag(status_flags::hash_calculated);
+ hashvalue = v;
+ }
+
+ return v;
+}
+
+/** By default, basic::evalf would evaluate the index value but we don't want
+ * a.1 to become a.(1.0). */
+ex idx::evalf(int level) const
+{
+ return *this;
+}
+
+ex idx::subs(const exmap & m, unsigned options) const
+{