* Implementation of GiNaC's ABC. */
/*
- * GiNaC Copyright (C) 1999-2003 Johannes Gutenberg University Mainz, Germany
+ * GiNaC Copyright (C) 1999-2006 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
*
* 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 <iostream>
/** 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. */
// 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.
- flags = 0;
+ fl &= ~(status_flags::evaluated | status_flags::expanded | status_flags::hash_calculated);
} else {
// The objects are of the exact same class, so copy the hash value.
hashvalue = other.hashvalue;
}
flags = fl;
- refcount = 0;
+ set_refcount(0);
return *this;
}
//////////
/** 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;
const print_context_class_info * pc_info = &c.get_class_info();
next_class:
-std::clog << "searching class " << reg_info->options.get_name() << std::endl;
const std::vector<print_functor> & pdt = reg_info->options.get_print_dispatch_table();
next_context:
-std::clog << "searching context " << pc_info->options.get_name() << ", ID " << pc_info->options.get_id() << std::endl;
unsigned id = pc_info->options.get_id();
if (id >= pdt.size() || !(pdt[id].is_valid())) {
} else {
// Call method
-std::clog << "method found, calling" << std::endl;
-std::clog << " this = " << class_name() << ", context = " << c.class_name() << std::endl;
pdt[id](*this, c, level);
}
}
/** Tree output to stream. */
void basic::do_print_tree(const print_tree & c, unsigned level) const
{
- c.s << std::string(level, ' ') << class_name()
- << std::hex << ", hash=0x" << hashvalue << ", flags=0x" << flags << std::dec
- << ", nops=" << nops()
- << std::endl;
+ c.s << std::string(level, ' ') << class_name() << " @" << this
+ << std::hex << ", hash=0x" << hashvalue << ", flags=0x" << flags << std::dec;
+ if (nops())
+ c.s << ", nops=" << nops();
+ c.s << std::endl;
for (size_t i=0; i<nops(); ++i)
op(i).print(c, level + c.delta_indent);
}
* @see basic::dbgprinttree */
void basic::dbgprint() const
{
- this->print(std::cerr);
+ this->print(print_dflt(std::cerr));
std::cerr << std::endl;
}
* 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; i<nops(); i++)
- if (op(i).has(pattern))
+ if (op(i).has(pattern, options))
return true;
return false;
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; i<num; i++)
- copy->let_op(i) = f(copy->op(i));
- return *copy;
+ basic *copy = NULL;
+ for (size_t i=0; i<num; i++) {
+ const ex & o = op(i);
+ const ex & n = f(o);
+ if (!are_ex_trivially_equal(o, n)) {
+ if (copy == NULL)
+ copy = duplicate();
+ copy->let_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. */
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
* (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() */
/** 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() */
* 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
if (is_exactly_a<wildcard>(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<basic>(it->op(1)));
exmap::const_iterator it;
if (options & subs_options::no_pattern) {
- it = m.find(*this);
+ ex thisex = *this;
+ it = m.find(thisex);
if (it != m.end())
return it->second;
+ return thisex;
} else {
for (it = m.begin(); it != m.end(); ++it) {
lst repl_lst;
return exvector(); // return an empty exvector
}
+ex basic::conjugate() const
+{
+ return *this;
+}
+
ex basic::eval_ncmul(const exvector & v) const
{
return hold_ncmul(v);
return return_types::commutative;
}
-unsigned basic::return_type_tinfo() const
+const basic* basic::return_type_tinfo() const
{
- return tinfo();
+ return this;
}
/** Compute the hash value of an object and if it makes sense to store it in
* 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; i<nops(); i++) {
v = rotate_left(v);
v ^= this->op(i).gethash();
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
* 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_this<hash_other) return -1;
if (hash_this>hash_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);
// 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: "
* @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);
}
* 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);
}
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
git://www.ginac.de / ginac.git / blobdiff