X-Git-Url: https://ginac.de/ginac.git//ginac.git?a=blobdiff_plain;ds=sidebyside;f=ginac%2Fidx.cpp;h=d0388d237fcdd9cdf5e6be3c857c0c7c1cd76b08;hb=27d6204effdef95a00af461fff98024e290dbaa7;hp=7088c5bd674ae6584c76b14ce2669448e38e6e2f;hpb=df5f8db62815995d87ebd4f97a5dbc0d1a327b94;p=ginac.git diff --git a/ginac/idx.cpp b/ginac/idx.cpp index 7088c5bd..d0388d23 100644 --- 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(other)); const idx &o = static_cast(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(other)); + const idx &o = static_cast(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(other)); const varidx &o = static_cast(other); int cmpval = inherited::compare_same_type(other); @@ -300,9 +308,19 @@ int varidx::compare_same_type(const basic & other) const return 0; } +bool varidx::match_same_type(const basic & other) const +{ + GINAC_ASSERT(is_a(other)); + const varidx &o = static_cast(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(other)); const spinidx &o = static_cast(other); // Check dottedness first so dummy indices will end up next to each other @@ -316,34 +334,21 @@ int spinidx::compare_same_type(const basic & other) const return 0; } -bool idx::match(const ex & pattern, lst & repl_lst) const +bool spinidx::match_same_type(const basic & other) const { - if (!is_ex_of_type(pattern, idx)) - return false; - const idx &o = ex_to_idx(pattern); - if (!dim.is_equal(o.dim)) - return false; - return value.match(o.value, repl_lst); -} + GINAC_ASSERT(is_a(other)); + const spinidx &o = static_cast(other); -bool varidx::match(const ex & pattern, lst & repl_lst) const -{ - if (!is_ex_of_type(pattern, varidx)) - return false; - const varidx &o = ex_to_varidx(pattern); - if (covariant != o.covariant) + if (dotted != o.dotted) return false; - return inherited::match(pattern, repl_lst); + return inherited::match_same_type(other); } -bool spinidx::match(const ex & pattern, lst & repl_lst) const +/** 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 { - if (!is_ex_of_type(pattern, spinidx)) - return false; - const spinidx &o = ex_to_spinidx(pattern); - if (dotted != o.dotted) - return false; - return inherited::match(pattern, repl_lst); + return *this; } ex idx::subs(const lst & ls, const lst & lr, bool no_pattern) const @@ -352,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.op(i)))) { // Substitution index->index if (is_ex_of_type(lr.op(i), idx)) @@ -377,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 ////////// @@ -469,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 -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(e1), ex_to(e2)); } void find_free_and_dummy(exvector::const_iterator it, exvector::const_iterator itend, exvector & out_free, exvector & out_dummy) @@ -513,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(*it).is_symbolic()) out_free.push_back(*it); return; } @@ -521,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(); @@ -533,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(*last).is_symbolic()) out_free.push_back(*last); } last = it++; } - if (ex_to_idx(*last).is_symbolic()) + if (ex_to(*last).is_symbolic()) out_free.push_back(*last); }