X-Git-Url: https://www.ginac.de/ginac.git//ginac.git?p=ginac.git;a=blobdiff_plain;f=ginac%2Fbasic.cpp;h=7a0633de19a18221f241292b21742416cdb29dce;hp=01a29011152a9c9ff7b58620e7a0da71c7561d75;hb=0f26d08929532724d24a60e9fa5e5e98c4b2fa55;hpb=0a5049a0354466a88862c67b1b9c9e27e36cc309 diff --git a/ginac/basic.cpp b/ginac/basic.cpp index 01a29011..7a0633de 100644 --- a/ginac/basic.cpp +++ b/ginac/basic.cpp @@ -3,7 +3,7 @@ * Implementation of GiNaC's ABC. */ /* - * GiNaC Copyright (C) 1999-2003 Johannes Gutenberg University Mainz, Germany + * GiNaC Copyright (C) 1999-2008 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,7 +17,7 @@ * * 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 @@ -30,6 +30,7 @@ #include "ex.h" #include "numeric.h" #include "power.h" +#include "add.h" #include "symbol.h" #include "lst.h" #include "ncmul.h" @@ -38,6 +39,7 @@ #include "wildcard.h" #include "archive.h" #include "utils.h" +#include "inifcns.h" namespace GiNaC { @@ -57,7 +59,6 @@ GINAC_IMPLEMENT_REGISTERED_CLASS_OPT(basic, void, * 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) { - GINAC_ASSERT(typeid(*this) == typeid(other)); } /** basic assignment operator: the other object might be of a derived class. */ @@ -208,7 +209,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; } @@ -287,13 +288,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; if (match(pattern, repl_lst)) return true; for (size_t i=0; isetflag(status_flags::dynallocated); - copy->clearflag(status_flags::hash_calculated | status_flags::expanded); - for (size_t i=0; ilet_op(i) = f(copy->op(i)); - return *copy; + basic *copy = NULL; + 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. */ @@ -352,56 +370,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_iterator xi=x.begin(); xi!=x.end(); ++xi) { + ex key = _ex1; + ex pre_coeff = *xi; + for (lst::const_iterator li=l.begin(); li!=l.end(); ++li) { + 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 (exmap::const_iterator mi=cmap.begin(); mi != cmap.end(); ++mi) + resv.push_back((mi->first)*(mi->second)); + return (new add(resv))->setflag(status_flags::dynallocated); } else { @@ -472,6 +466,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) { 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 @@ -486,7 +494,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() */ @@ -498,7 +506,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() */ @@ -514,7 +522,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 @@ -549,8 +557,8 @@ bool basic::match(const ex & pattern, lst & repl_lst) const if (is_exactly_a(pattern)) { // Wildcard matches anything, but check whether we already have found - // a match for that wildcard first (if so, it the earlier match must - // be the same expression) + // 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))); @@ -577,12 +585,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. + lst tmp_repl = repl_lst; // Otherwise the subexpressions must match one-to-one for (size_t i=0; isecond; + return thisex; } else { for (it = m.begin(); it != m.end(); ++it) { lst repl_lst; @@ -674,6 +690,21 @@ exvector basic::get_free_indices() const return exvector(); // return an empty exvector } +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); @@ -744,9 +775,9 @@ unsigned basic::return_type() const return return_types::commutative; } -unsigned basic::return_type_tinfo() const +tinfo_t basic::return_type_tinfo() const { - return tinfo(); + return tinfo_key; } /** Compute the hash value of an object and if it makes sense to store it in @@ -757,7 +788,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 = golden_ratio_hash((p_int)tinfo()); for (size_t i=0; iop(i).gethash(); @@ -776,7 +807,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 expand(e, options); } + ex operator()(const ex & e) { return e.expand(options); } }; /** Expand expression, i.e. multiply it out and return the result as a new @@ -803,13 +834,19 @@ ex basic::expand(unsigned options) const * 1 greater. */ int basic::compare(const basic & other) const { +#ifdef GINAC_COMPARE_STATISTICS + compare_statistics.total_basic_compares++; +#endif const unsigned hash_this = gethash(); const unsigned hash_other = other.gethash(); if (hash_thishash_other) return 1; +#ifdef GINAC_COMPARE_STATISTICS + compare_statistics.compare_same_hashvalue++; +#endif - const unsigned typeid_this = tinfo(); - const unsigned typeid_other = other.tinfo(); + const tinfo_t typeid_this = tinfo(); + const tinfo_t typeid_other = other.tinfo(); if (typeid_this==typeid_other) { GINAC_ASSERT(typeid(*this)==typeid(other)); // int cmpval = compare_same_type(other); @@ -822,6 +859,9 @@ int basic::compare(const basic & other) const // std::cout << std::endl; // } // return cmpval; +#ifdef GINAC_COMPARE_STATISTICS + compare_statistics.compare_same_type++; +#endif return compare_same_type(other); } else { // std::cout << "hash collision, different types: " @@ -842,13 +882,22 @@ int basic::compare(const basic & other) const * @see is_equal_same_type */ bool basic::is_equal(const basic & other) const { +#ifdef GINAC_COMPARE_STATISTICS + compare_statistics.total_basic_is_equals++; +#endif if (this->gethash()!=other.gethash()) return false; +#ifdef GINAC_COMPARE_STATISTICS + compare_statistics.is_equal_same_hashvalue++; +#endif if (this->tinfo()!=other.tinfo()) return false; GINAC_ASSERT(typeid(*this)==typeid(other)); +#ifdef GINAC_COMPARE_STATISTICS + compare_statistics.is_equal_same_type++; +#endif return is_equal_same_type(other); } @@ -877,4 +926,27 @@ void basic::ensure_if_modifiable() const int max_recursion_level = 1024; + +#ifdef GINAC_COMPARE_STATISTICS +compare_statistics_t::~compare_statistics_t() +{ + std::clog << "ex::compare() called " << total_compares << " times" << std::endl; + std::clog << "nontrivial compares: " << nontrivial_compares << " times" << std::endl; + std::clog << "basic::compare() called " << total_basic_compares << " times" << std::endl; + std::clog << "same hashvalue in compare(): " << compare_same_hashvalue << " times" << std::endl; + std::clog << "compare_same_type() called " << compare_same_type << " times" << std::endl; + std::clog << std::endl; + std::clog << "ex::is_equal() called " << total_is_equals << " times" << std::endl; + std::clog << "nontrivial is_equals: " << nontrivial_is_equals << " times" << std::endl; + std::clog << "basic::is_equal() called " << total_basic_is_equals << " times" << std::endl; + std::clog << "same hashvalue in is_equal(): " << is_equal_same_hashvalue << " times" << std::endl; + std::clog << "is_equal_same_type() called " << is_equal_same_type << " times" << std::endl; + std::clog << std::endl; + std::clog << "basic::gethash() called " << total_gethash << " times" << std::endl; + std::clog << "used cached hashvalue " << gethash_cached << " times" << std::endl; +} + +compare_statistics_t compare_statistics; +#endif + } // namespace GiNaC