X-Git-Url: https://www.ginac.de/ginac.git//ginac.git?a=blobdiff_plain;f=ginac%2Fbasic.cpp;h=3a2768418c5705aa0e7cb8078e88fc70834c7254;hb=b60d73e12181182b5afd3d37363d99151628b92b;hp=b86900795d950c542bf5f0dc9e281c6c4063fc4e;hpb=13896261ee985f23e5b5648532e70f0cce704ede;p=ginac.git diff --git a/ginac/basic.cpp b/ginac/basic.cpp index b8690079..3a276841 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-2004 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 @@ -55,9 +55,8 @@ 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), refcount(0) +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. */ @@ -74,7 +73,7 @@ const basic & basic::operator=(const basic & other) hashvalue = other.hashvalue; } flags = fl; - refcount = 0; + set_refcount(0); return *this; } @@ -93,7 +92,7 @@ const basic & basic::operator=(const basic & other) ////////// /** Construct object from archive_node. */ -basic::basic(const archive_node &n, lst &sym_lst) : flags(0), refcount(0) +basic::basic(const archive_node &n, lst &sym_lst) : flags(0) { // Reconstruct tinfo_key from class name std::string class_name; @@ -307,12 +306,23 @@ ex basic::map(map_function & f) const if (num == 0) return *this; - basic *copy = duplicate(); - copy->setflag(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; } /** Return degree of highest power in object s. */ @@ -486,7 +496,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 +508,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 +524,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 +559,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))); @@ -674,6 +684,11 @@ exvector basic::get_free_indices() const return exvector(); // return an empty exvector } +ex basic::conjugate() const +{ + return *this; +} + ex basic::eval_ncmul(const exvector & v) const { return hold_ncmul(v); @@ -776,7 +791,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,10 +818,16 @@ 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(); @@ -822,6 +843,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 +866,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); } @@ -866,7 +899,7 @@ const basic & basic::hold() const * is not the case. */ void basic::ensure_if_modifiable() const { - if (refcount > 1) + if (get_refcount() > 1) throw(std::runtime_error("cannot modify multiply referenced object")); clearflag(status_flags::hash_calculated | status_flags::evaluated); } @@ -877,4 +910,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