X-Git-Url: https://www.ginac.de/ginac.git//ginac.git?p=ginac.git;a=blobdiff_plain;f=ginac%2Fidx.cpp;h=74754022e63f6f73996404d3e2ea389cd0d2fa5e;hp=d54f51921f9e1a0791efa29f792537f5fa6cdcd2;hb=6a289cac851857096561ee8ecb32ee4ba8a28ac4;hpb=df7b9291027e0e5bda65e07fe251469ef964e704 diff --git a/ginac/idx.cpp b/ginac/idx.cpp index d54f5192..74754022 100644 --- a/ginac/idx.cpp +++ b/ginac/idx.cpp @@ -20,8 +20,8 @@ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ +#include #include -#include #include "idx.h" #include "symbol.h" @@ -29,7 +29,6 @@ #include "print.h" #include "archive.h" #include "utils.h" -#include "debugmsg.h" namespace GiNaC { @@ -38,23 +37,18 @@ GINAC_IMPLEMENT_REGISTERED_CLASS(varidx, idx) GINAC_IMPLEMENT_REGISTERED_CLASS(spinidx, varidx) ////////// -// default constructor, destructor, copy constructor assignment operator and helpers +// default ctor, dtor, copy ctor, assignment operator and helpers ////////// -idx::idx() : inherited(TINFO_idx) -{ - debugmsg("idx default constructor", LOGLEVEL_CONSTRUCT); -} +idx::idx() : inherited(TINFO_idx) {} varidx::varidx() : covariant(false) { - debugmsg("varidx default constructor", LOGLEVEL_CONSTRUCT); tinfo_key = TINFO_varidx; } spinidx::spinidx() : dotted(false) { - debugmsg("spinidx default constructor", LOGLEVEL_CONSTRUCT); tinfo_key = TINFO_spinidx; } @@ -87,7 +81,6 @@ DEFAULT_DESTROY(spinidx) idx::idx(const ex & v, const ex & d) : inherited(TINFO_idx), value(v), dim(d) { - debugmsg("idx constructor from ex,ex", LOGLEVEL_CONSTRUCT); if (is_dim_numeric()) if (!dim.info(info_flags::posint)) throw(std::invalid_argument("dimension of space must be a positive integer")); @@ -95,13 +88,11 @@ idx::idx(const ex & v, const ex & d) : inherited(TINFO_idx), value(v), dim(d) varidx::varidx(const ex & v, const ex & d, bool cov) : inherited(v, d), covariant(cov) { - debugmsg("varidx constructor from ex,ex,bool", LOGLEVEL_CONSTRUCT); tinfo_key = TINFO_varidx; } spinidx::spinidx(const ex & v, const ex & d, bool cov, bool dot) : inherited(v, d, cov), dotted(dot) { - debugmsg("spinidx constructor from ex,ex,bool,bool", LOGLEVEL_CONSTRUCT); tinfo_key = TINFO_spinidx; } @@ -111,20 +102,17 @@ spinidx::spinidx(const ex & v, const ex & d, bool cov, bool dot) : inherited(v, idx::idx(const archive_node &n, const lst &sym_lst) : inherited(n, sym_lst) { - debugmsg("idx constructor from archive_node", LOGLEVEL_CONSTRUCT); n.find_ex("value", value, sym_lst); n.find_ex("dim", dim, sym_lst); } varidx::varidx(const archive_node &n, const lst &sym_lst) : inherited(n, sym_lst) { - debugmsg("varidx constructor from archive_node", LOGLEVEL_CONSTRUCT); n.find_bool("covariant", covariant); } spinidx::spinidx(const archive_node &n, const lst &sym_lst) : inherited(n, sym_lst) { - debugmsg("spinidx constructor from archive_node", LOGLEVEL_CONSTRUCT); n.find_bool("dotted", dotted); } @@ -152,13 +140,11 @@ 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 { - debugmsg("idx print", LOGLEVEL_PRINT); - if (is_of_type(c, print_tree)) { c.s << std::string(level, ' ') << class_name() @@ -183,8 +169,6 @@ void idx::print(const print_context & c, unsigned level) const void varidx::print(const print_context & c, unsigned level) const { - debugmsg("varidx print", LOGLEVEL_PRINT); - if (is_of_type(c, print_tree)) { c.s << std::string(level, ' ') << class_name() @@ -214,8 +198,6 @@ void varidx::print(const print_context & c, unsigned level) const void spinidx::print(const print_context & c, unsigned level) const { - debugmsg("spinidx print", LOGLEVEL_PRINT); - if (is_of_type(c, print_tree)) { c.s << std::string(level, ' ') << class_name() @@ -276,7 +258,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 +267,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,31 +290,56 @@ 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 + 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(other)); + const spinidx &o = static_cast(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) const +ex idx::subs(const lst & ls, const lst & lr, bool no_pattern) const { GINAC_ASSERT(ls.nops() == lr.nops()); // 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)) @@ -339,7 +354,7 @@ ex idx::subs(const lst & ls, const lst & lr) const } // None, substitute objects in value (not in dimension) - const ex &subsed_value = value.subs(ls, lr); + const ex &subsed_value = value.subs(ls, lr, no_pattern); if (are_ex_trivially_equal(value, subsed_value)) return *this; @@ -349,6 +364,14 @@ ex idx::subs(const lst & ls, const lst & lr) 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 +464,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) @@ -485,7 +478,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; } @@ -493,7 +486,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 +498,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); }