added checks for generalized clifford units

[ginac.git] / ginac / basic.cpp

diff --git a/ginac/basic.cpp b/ginac/basic.cpp
index 038cd7b571fdb6e93aca0f38569add33e6b9fc0f..17f265debbe27f9b5c35d07b0599ed108c6469c5 100644 (file)
--- a/ginac/basic.cpp
+++ b/ginac/basic.cpp
@@ -307,12 +307,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; 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. */
@@ -549,8 +560,8 @@ bool basic::match(const ex & pattern, lst & repl_lst) const
        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)));
@@ -781,7 +792,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
@@ -808,10 +819,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_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();
@@ -827,6 +844,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: " 
@@ -847,13 +867,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);
 }
 
@@ -882,4 +911,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