* Some internal reorganization WRT flyweight handling and initialization,

[ginac.git] / ginac / idx.cpp

diff --git a/ginac/idx.cpp b/ginac/idx.cpp
index 117a02b2a0757e86a4b9927812074df8ac4921be..d0388d237fcdd9cdf5e6be3c857c0c7c1cd76b08 100644 (file)
--- a/ginac/idx.cpp
+++ b/ginac/idx.cpp
@@ -152,7 +152,7 @@ DEFAULT_UNARCHIVE(varidx)
 DEFAULT_UNARCHIVE(spinidx)
 
 //////////
-// functions overriding virtual functions from bases classes
+// functions overriding virtual functions from base classes
 //////////
 
 void idx::print(const print_context & c, unsigned level) const
@@ -276,7 +276,7 @@ ex & idx::let_op(int i)
  *  must be such that dummy indices lie next to each other. */
 int idx::compare_same_type(const basic & other) const
 {
-       GINAC_ASSERT(is_of_type(other, idx));
+       GINAC_ASSERT(is_a<idx>(other));
        const idx &o = static_cast<const idx &>(other);
 
        int cmpval = value.compare(o.value);
@@ -285,9 +285,17 @@ int idx::compare_same_type(const basic & other) const
        return dim.compare(o.dim);
 }
 
+bool idx::match_same_type(const basic & other) const
+{
+       GINAC_ASSERT(is_a<idx>(other));
+       const idx &o = static_cast<const idx &>(other);
+
+       return dim.is_equal(o.dim);
+}
+
 int varidx::compare_same_type(const basic & other) const
 {
-       GINAC_ASSERT(is_of_type(other, varidx));
+       GINAC_ASSERT(is_a<varidx>(other));
        const varidx &o = static_cast<const varidx &>(other);
 
        int cmpval = inherited::compare_same_type(other);
@@ -300,22 +308,47 @@ int varidx::compare_same_type(const basic & other) const
        return 0;
 }
 
+bool varidx::match_same_type(const basic & other) const
+{
+       GINAC_ASSERT(is_a<varidx>(other));
+       const varidx &o = static_cast<const varidx &>(other);
+
+       if (covariant != o.covariant)
+               return false;
+       return inherited::match_same_type(other);
+}
+
 int spinidx::compare_same_type(const basic & other) const
 {
-       GINAC_ASSERT(is_of_type(other, spinidx));
+       GINAC_ASSERT(is_a<spinidx>(other));
        const spinidx &o = static_cast<const spinidx &>(other);
 
+       // 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;
 
-       // Check variance and dottedness last so dummy indices will end up next to each other
-       if (covariant != o.covariant)
-               return covariant ? -1 : 1;
+       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 dotted ? -1 : 1;
+               return false;
+       return inherited::match_same_type(other);
+}
 
-       return 0;
+/** 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 lst & ls, const lst & lr, bool no_pattern) const
@@ -324,7 +357,7 @@ ex idx::subs(const lst & ls, const lst & lr, bool no_pattern) const
 
        // First look for index substitutions
        for (unsigned i=0; i<ls.nops(); i++) {
-               if (is_equal(*(ls.op(i)).bp)) {
+               if (is_equal(ex_to<basic>(ls.op(i)))) {
 
                        // Substitution index->index
                        if (is_ex_of_type(lr.op(i), idx))
@@ -349,6 +382,14 @@ ex idx::subs(const lst & ls, const lst & lr, bool no_pattern) const
        return i_copy->setflag(status_flags::dynallocated);
 }
 
+/** Implementation of ex::diff() for an index always returns 0.
+ *
+ *  @see ex::diff */
+ex idx::derivative(const symbol & s) const
+{
+       return _ex0;
+}
+
 //////////
 // new virtual functions
 //////////
@@ -441,37 +482,7 @@ bool is_dummy_pair(const ex & e1, const ex & e2)
        if (!is_ex_of_type(e1, idx) || !is_ex_of_type(e2, idx))
                return false;
 
-       return is_dummy_pair(ex_to_idx(e1), ex_to_idx(e2));
-}
-
-// Shaker sort is sufficient for the expected small number of indices
-template <class It, class Cmp>
-inline void shaker_sort(It first, It last, Cmp comp)
-{
-       if (first == last)
-               return;
-       --last;
-       if (first == last)
-               return;
-       It flag = first;
-       do {
-               It i;
-               for (i=last; i>first; --i) {
-                       if (comp(*i, i[-1])) {
-                               iter_swap(i-1, i);
-                               flag = i - 1;
-                       }
-               }
-               ++flag;
-               first = flag;
-               for (i=first; i<last; ++i) {
-                       if (comp(i[1], *i)) {
-                               iter_swap(i, i+1);
-                               flag = i + 1;
-                       }
-               }
-               last = flag - 1;
-       } while (first <= last);
+       return is_dummy_pair(ex_to<idx>(e1), ex_to<idx>(e2));
 }
 
 void find_free_and_dummy(exvector::const_iterator it, exvector::const_iterator itend, exvector & out_free, exvector & out_dummy)
@@ -485,7 +496,7 @@ void find_free_and_dummy(exvector::const_iterator it, exvector::const_iterator i
 
        // Only one index? Then it is a free one if it's not numeric
        if (itend - it == 1) {
-               if (ex_to_idx(*it).is_symbolic())
+               if (ex_to<idx>(*it).is_symbolic())
                        out_free.push_back(*it);
                return;
        }
@@ -493,7 +504,7 @@ void find_free_and_dummy(exvector::const_iterator it, exvector::const_iterator i
        // Sort index vector. This will cause dummy indices come to lie next
        // to each other (because the sort order is defined to guarantee this).
        exvector v(it, itend);
-       shaker_sort(v.begin(), v.end(), ex_is_less());
+       shaker_sort(v.begin(), v.end(), ex_is_less(), ex_swap());
 
        // Find dummy pairs and free indices
        it = v.begin(); itend = v.end();
@@ -505,12 +516,12 @@ void find_free_and_dummy(exvector::const_iterator it, exvector::const_iterator i
                        if (it == itend)
                                return;
                } else {
-                       if (!it->is_equal(*last) && ex_to_idx(*last).is_symbolic())
+                       if (!it->is_equal(*last) && ex_to<idx>(*last).is_symbolic())
                                out_free.push_back(*last);
                }
                last = it++;
        }
-       if (ex_to_idx(*last).is_symbolic())
+       if (ex_to<idx>(*last).is_symbolic())
                out_free.push_back(*last);
 }