X-Git-Url: https://www.ginac.de/ginac.git//ginac.git?p=ginac.git;a=blobdiff_plain;f=ginac%2Fbasic.cpp;h=0dfa7d785dd796ad3c1ecf70871c4e54a93d0d07;hp=17f265debbe27f9b5c35d07b0599ed108c6469c5;hb=25b4d894b5b2f7f56fb49e62a7767ab969d5249f;hpb=23acc666fcef311fd97092aee7f8c55e80395351 diff --git a/ginac/basic.cpp b/ginac/basic.cpp index 17f265de..0dfa7d78 100644 --- a/ginac/basic.cpp +++ b/ginac/basic.cpp @@ -3,7 +3,7 @@ * Implementation of GiNaC's ABC. */ /* - * GiNaC Copyright (C) 1999-2004 Johannes Gutenberg University Mainz, Germany + * GiNaC Copyright (C) 1999-2016 Johannes Gutenberg University Mainz, Germany * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by @@ -17,19 +17,14 @@ * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ -#include -#include -#ifdef DO_GINAC_ASSERT -# include -#endif - #include "basic.h" #include "ex.h" #include "numeric.h" #include "power.h" +#include "add.h" #include "symbol.h" #include "lst.h" #include "ncmul.h" @@ -38,6 +33,12 @@ #include "wildcard.h" #include "archive.h" #include "utils.h" +#include "hash_seed.h" +#include "inifcns.h" + +#include +#include +#include namespace GiNaC { @@ -55,16 +56,15 @@ GINAC_IMPLEMENT_REGISTERED_CLASS_OPT(basic, void, /** basic copy constructor: implicitly assumes that the other class is of * the exact same type (as it's used by duplicate()), so it can copy the * tinfo_key and the hash value. */ -basic::basic(const basic & other) : tinfo_key(other.tinfo_key), flags(other.flags & ~status_flags::dynallocated), hashvalue(other.hashvalue) +basic::basic(const basic & other) : flags(other.flags & ~status_flags::dynallocated), hashvalue(other.hashvalue) { - GINAC_ASSERT(typeid(*this) == typeid(other)); } /** basic assignment operator: the other object might be of a derived class. */ const basic & basic::operator=(const basic & other) { unsigned fl = other.flags & ~status_flags::dynallocated; - if (tinfo_key != other.tinfo_key) { + if (typeid(*this) != typeid(other)) { // The other object is of a derived class, so clear the flags as they // might no longer apply (especially hash_calculated). Oh, and don't // copy the tinfo_key: it is already set correctly for this object. @@ -93,18 +93,8 @@ const basic & basic::operator=(const basic & other) ////////// /** Construct object from archive_node. */ -basic::basic(const archive_node &n, lst &sym_lst) : flags(0) -{ - // Reconstruct tinfo_key from class name - std::string class_name; - if (n.find_string("class", class_name)) - tinfo_key = find_tinfo_key(class_name); - else - throw (std::runtime_error("archive node contains no class name")); -} - -/** Unarchive the object. */ -DEFAULT_UNARCHIVE(basic) +void basic::read_archive(const archive_node& n, lst& syms) +{ } /** Archive the object. */ void basic::archive(archive_node &n) const @@ -208,7 +198,7 @@ void basic::do_print_python_repr(const print_python_repr & c, unsigned level) co * @see basic::dbgprinttree */ void basic::dbgprint() const { - this->print(std::cerr); + this->print(print_dflt(std::cerr)); std::cerr << std::endl; } @@ -250,7 +240,7 @@ ex basic::op(size_t i) const throw(std::range_error(std::string("basic::op(): ") + class_name() + std::string(" has no operands"))); } -/** Return modifyable operand/member at position i. */ +/** Return modifiable operand/member at position i. */ ex & basic::let_op(size_t i) { ensure_if_modifiable(); @@ -287,13 +277,13 @@ ex & basic::operator[](size_t i) * the pattern itself or one of the children 'has' it. As a consequence * (according to the definition of children) given e=x+y+z, e.has(x) is true * but e.has(x+y) is false. */ -bool basic::has(const ex & pattern) const +bool basic::has(const ex & pattern, unsigned options) const { - lst repl_lst; + exmap repl_lst; if (match(pattern, repl_lst)) return true; for (size_t i=0; ilet_op(i) = n; } } if (copy) { - copy->setflag(status_flags::dynallocated); copy->clearflag(status_flags::hash_calculated | status_flags::expanded); return *copy; } else return *this; } +/** Check whether this is a polynomial in the given variables. */ +bool basic::is_polynomial(const ex & var) const +{ + return !has(var) || is_equal(ex_to(var)); +} + /** Return degree of highest power in object s. */ int basic::degree(const ex & s) const { @@ -363,56 +358,32 @@ ex basic::collect(const ex & s, bool distributed) const else if (distributed) { - // Get lower/upper degree of all symbols in list - size_t num = s.nops(); - struct sym_info { - ex sym; - int ldeg, deg; - int cnt; // current degree, 'counter' - ex coeff; // coefficient for degree 'cnt' - }; - sym_info *si = new sym_info[num]; - ex c = *this; - for (size_t i=0; ildegree(si[i].sym); - si[i].deg = this->degree(si[i].sym); - c = si[i].coeff = c.coeff(si[i].sym, si[i].cnt); - } - - while (true) { - - // Calculate coeff*x1^c1*...*xn^cn - ex y = _ex1; - for (size_t i=0; iexpand(); + if (! is_a(x)) + return x; + const lst& l(ex_to(s)); + + exmap cmap; + cmap[_ex1] = _ex0; + for (const auto & xi : x) { + ex key = _ex1; + ex pre_coeff = xi; + for (auto & li : l) { + int cexp = pre_coeff.degree(li); + pre_coeff = pre_coeff.coeff(li, cexp); + key *= pow(li, cexp); } + exmap::iterator ci = cmap.find(key); + if (ci != cmap.end()) + ci->second += pre_coeff; + else + cmap.insert(exmap::value_type(key, pre_coeff)); } -done: delete[] si; + exvector resv; + for (auto & mi : cmap) + resv.push_back((mi.first)*(mi.second)); + return dynallocate(resv); } else { @@ -439,7 +410,7 @@ done: delete[] si; } /** Perform automatic non-interruptive term rewriting rules. */ -ex basic::eval(int level) const +ex basic::eval() const { // There is nothing to do for basic objects: return hold(); @@ -447,31 +418,23 @@ ex basic::eval(int level) const /** Function object to be applied by basic::evalf(). */ struct evalf_map_function : public map_function { - int level; - evalf_map_function(int l) : level(l) {} - ex operator()(const ex & e) { return evalf(e, level); } + ex operator()(const ex & e) override { return evalf(e); } }; /** Evaluate object numerically. */ -ex basic::evalf(int level) const +ex basic::evalf() const { if (nops() == 0) return *this; else { - if (level == 1) - return *this; - else if (level == -max_recursion_level) - throw(std::runtime_error("max recursion level reached")); - else { - evalf_map_function map_evalf(level - 1); - return map(map_evalf); - } + evalf_map_function map_evalf; + return map(map_evalf); } } /** Function object to be applied by basic::evalm(). */ struct evalm_map_function : public map_function { - ex operator()(const ex & e) { return evalm(e); } + ex operator()(const ex & e) override { return evalm(e); } } map_evalm; /** Evaluate sums, products and integer powers of matrices. */ @@ -483,6 +446,20 @@ ex basic::evalm() const return map(map_evalm); } +/** Function object to be applied by basic::eval_integ(). */ +struct eval_integ_map_function : public map_function { + ex operator()(const ex & e) override { return eval_integ(e); } +} map_eval_integ; + +/** Evaluate integrals, if result is known. */ +ex basic::eval_integ() const +{ + if (nops() == 0) + return *this; + else + return map(map_eval_integ); +} + /** Perform automatic symbolic evaluations on indexed expression that * contains this object as the base expression. */ ex basic::eval_indexed(const basic & i) const @@ -497,7 +474,7 @@ ex basic::eval_indexed(const basic & i) const * (or a subclass) and their indices are compatible. This function is used * internally by simplify_indexed(). * - * @param self First indexed expression; it's base object is *this + * @param self First indexed expression; its base object is *this * @param other Second indexed expression * @return sum of self and other * @see ex::simplify_indexed() */ @@ -509,7 +486,7 @@ ex basic::add_indexed(const ex & self, const ex & other) const /** Multiply an indexed expression with a scalar. This function is used * internally by simplify_indexed(). * - * @param self Indexed expression; it's base object is *this + * @param self Indexed expression; its base object is *this * @param other Numeric value * @return product of self and other * @see ex::simplify_indexed() */ @@ -525,7 +502,7 @@ ex basic::scalar_mul_indexed(const ex & self, const numeric & other) const * and that at least one dummy index has been found. This functions is * used internally by simplify_indexed(). * - * @param self Pointer to first indexed expression; it's base object is *this + * @param self Pointer to first indexed expression; its base object is *this * @param other Pointer to second indexed expression * @param v The complete vector of factors * @return true if the contraction was successful, false otherwise @@ -537,9 +514,9 @@ bool basic::contract_with(exvector::iterator self, exvector::iterator other, exv } /** Check whether the expression matches a given pattern. For every wildcard - * object in the pattern, an expression of the form "wildcard == matching_expression" - * is added to repl_lst. */ -bool basic::match(const ex & pattern, lst & repl_lst) const + * object in the pattern, a pair with the wildcard as a key and matching + * expression as a value is added to repl_lst. */ +bool basic::match(const ex & pattern, exmap& repl_lst) const { /* Sweet sweet shapes, sweet sweet shapes, @@ -562,17 +539,17 @@ bool basic::match(const ex & pattern, lst & repl_lst) const // Wildcard matches anything, but check whether we already have found // a match for that wildcard first (if so, the earlier match must be // the same expression) - for (lst::const_iterator it = repl_lst.begin(); it != repl_lst.end(); ++it) { - if (it->op(0).is_equal(pattern)) - return is_equal(ex_to(it->op(1))); + for (auto & it : repl_lst) { + if (it.first.is_equal(pattern)) + return is_equal(ex_to(it.second)); } - repl_lst.append(pattern == *this); + repl_lst[pattern] = *this; return true; } else { // Expression must be of the same type as the pattern - if (tinfo() != ex_to(pattern).tinfo()) + if (typeid(*this) != typeid(ex_to(pattern))) return false; // Number of subexpressions must match @@ -588,12 +565,18 @@ bool basic::match(const ex & pattern, lst & repl_lst) const if (!match_same_type(ex_to(pattern))) return false; + // Even if the expression does not match the pattern, some of + // its subexpressions could match it. For example, x^5*y^(-1) + // does not match the pattern $0^5, but its subexpression x^5 + // does. So, save repl_lst in order to not add bogus entries. + exmap tmp_repl = repl_lst; // Otherwise the subexpressions must match one-to-one for (size_t i=0; isecond; + return *this; } else { - for (it = m.begin(); it != m.end(); ++it) { - lst repl_lst; - if (match(ex_to(it->first), repl_lst)) - return it->second.subs(repl_lst, options | subs_options::no_pattern); // avoid infinite recursion when re-substituting the wildcards + for (auto & it : m) { + exmap repl_lst; + if (match(ex_to(it.first), repl_lst)) + return it.second.subs(repl_lst, options | subs_options::no_pattern); + // avoid infinite recursion when re-substituting the wildcards } } @@ -633,7 +616,6 @@ ex basic::subs(const exmap & m, unsigned options) const // Something changed, clone the object basic *copy = duplicate(); - copy->setflag(status_flags::dynallocated); copy->clearflag(status_flags::hash_calculated | status_flags::expanded); // Substitute the changed operand @@ -690,6 +672,16 @@ ex basic::conjugate() const return *this; } +ex basic::real_part() const +{ + return real_part_function(*this).hold(); +} + +ex basic::imag_part() const +{ + return imag_part_function(*this).hold(); +} + ex basic::eval_ncmul(const exvector & v) const { return hold_ncmul(v); @@ -701,7 +693,7 @@ ex basic::eval_ncmul(const exvector & v) const struct derivative_map_function : public map_function { const symbol &s; derivative_map_function(const symbol &sym) : s(sym) {} - ex operator()(const ex & e) { return diff(e, s); } + ex operator()(const ex & e) override { return diff(e, s); } }; /** Default implementation of ex::diff(). It maps the operation on the @@ -760,9 +752,12 @@ unsigned basic::return_type() const return return_types::commutative; } -unsigned basic::return_type_tinfo() const +return_type_t basic::return_type_tinfo() const { - return tinfo(); + return_type_t rt; + rt.tinfo = &typeid(*this); + rt.rl = 0; + return rt; } /** Compute the hash value of an object and if it makes sense to store it in @@ -773,7 +768,7 @@ unsigned basic::return_type_tinfo() const * would all end up with the same hashvalue. */ unsigned basic::calchash() const { - unsigned v = golden_ratio_hash(tinfo()); + unsigned v = make_hash_seed(typeid(*this)); for (size_t i=0; iop(i).gethash(); @@ -792,7 +787,7 @@ unsigned basic::calchash() const struct expand_map_function : public map_function { unsigned options; expand_map_function(unsigned o) : options(o) {} - ex operator()(const ex & e) { return e.expand(options); } + ex operator()(const ex & e) override { return e.expand(options); } }; /** Expand expression, i.e. multiply it out and return the result as a new @@ -830,10 +825,9 @@ int basic::compare(const basic & other) const compare_statistics.compare_same_hashvalue++; #endif - const unsigned typeid_this = tinfo(); - const unsigned typeid_other = other.tinfo(); - if (typeid_this==typeid_other) { - GINAC_ASSERT(typeid(*this)==typeid(other)); + const std::type_info& typeid_this = typeid(*this); + const std::type_info& typeid_other = typeid(other); + if (typeid_this == typeid_other) { // int cmpval = compare_same_type(other); // if (cmpval!=0) { // std::cout << "hash collision, same type: " @@ -855,7 +849,7 @@ int basic::compare(const basic & other) const // std::cout << " and "; // other.print(print_tree(std::cout)); // std::cout << std::endl; - return (typeid_thistinfo()!=other.tinfo()) + if (typeid(*this) != typeid(other)) return false; - GINAC_ASSERT(typeid(*this)==typeid(other)); - #ifdef GINAC_COMPARE_STATISTICS compare_statistics.is_equal_same_type++; #endif @@ -909,9 +901,6 @@ void basic::ensure_if_modifiable() const // global variables ////////// -int max_recursion_level = 1024; - - #ifdef GINAC_COMPARE_STATISTICS compare_statistics_t::~compare_statistics_t() {