X-Git-Url: https://www.ginac.de/ginac.git//ginac.git?p=ginac.git;a=blobdiff_plain;f=ginac%2Fbasic.cpp;h=f9f18f5ca13b8f6e0a82ba54b2a5a1ae4cba7991;hp=7a0633de19a18221f241292b21742416cdb29dce;hb=0256e2fe48a0ecce79c37ac209620ca852b7f11a;hpb=192ed7390b7b2b705ad100e3db0a92eedd2b20ad diff --git a/ginac/basic.cpp b/ginac/basic.cpp index 7a0633de..f9f18f5c 100644 --- a/ginac/basic.cpp +++ b/ginac/basic.cpp @@ -3,7 +3,7 @@ * Implementation of GiNaC's ABC. */ /* - * GiNaC Copyright (C) 1999-2008 Johannes Gutenberg University Mainz, Germany + * GiNaC Copyright (C) 1999-2009 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 @@ -20,12 +20,6 @@ * 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" @@ -39,8 +33,13 @@ #include "wildcard.h" #include "archive.h" #include "utils.h" +#include "hash_seed.h" #include "inifcns.h" +#include +#include +#include + namespace GiNaC { GINAC_IMPLEMENT_REGISTERED_CLASS_OPT(basic, void, @@ -57,7 +56,7 @@ 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) { } @@ -65,7 +64,7 @@ basic::basic(const basic & other) : tinfo_key(other.tinfo_key), flags(other.flag 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. @@ -94,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 @@ -290,7 +279,7 @@ ex & basic::operator[](size_t i) * but e.has(x+y) is false. */ 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; iop(0).is_equal(pattern)) - return is_equal(ex_to(it->op(1))); + for (exmap::const_iterator it = repl_lst.begin(); it != repl_lst.end(); ++it) { + 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 @@ -589,7 +578,7 @@ bool basic::match(const ex & pattern, lst & repl_lst) const // 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; + exmap tmp_repl = repl_lst; // Otherwise the subexpressions must match one-to-one for (size_t i=0; i(it->first), repl_lst)) - return it->second.subs(repl_lst, options | subs_options::no_pattern); // avoid infinite recursion when re-substituting the wildcards + return it->second.subs(repl_lst, options | subs_options::no_pattern); + // avoid infinite recursion when re-substituting the wildcards } } @@ -775,9 +765,12 @@ unsigned basic::return_type() const return return_types::commutative; } -tinfo_t basic::return_type_tinfo() const +return_type_t basic::return_type_tinfo() const { - return tinfo_key; + 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 @@ -788,7 +781,7 @@ tinfo_t basic::return_type_tinfo() const * would all end up with the same hashvalue. */ unsigned basic::calchash() const { - unsigned v = golden_ratio_hash((p_int)tinfo()); + unsigned v = make_hash_seed(typeid(*this)); for (size_t i=0; iop(i).gethash(); @@ -845,10 +838,9 @@ int basic::compare(const basic & other) const compare_statistics.compare_same_hashvalue++; #endif - const tinfo_t typeid_this = tinfo(); - const tinfo_t 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: " @@ -870,7 +862,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