[bugfix] Make sure add::eval() collects all numeric terms *correctly*.

[ginac.git] / ginac / add.cpp

diff --git a/ginac/add.cpp b/ginac/add.cpp
index 6548366ee16f1facb3dab2c1751444730171f236..1a19d86d863b79cdf7fd8977ed37ff04cbefbce0 100644 (file)
--- a/ginac/add.cpp
+++ b/ginac/add.cpp
@@ -3,7 +3,7 @@
  *  Implementation of GiNaC's sums of expressions. */
 
 /*
- *  GiNaC Copyright (C) 1999-2010 Johannes Gutenberg University Mainz, Germany
+ *  GiNaC Copyright (C) 1999-2015 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
@@ -28,6 +28,7 @@
 #include "utils.h"
 #include "clifford.h"
 #include "ncmul.h"
+#include "compiler.h"
 
 #include <iostream>
 #include <limits>
@@ -259,6 +260,16 @@ bool add::info(unsigned inf) const
        return inherited::info(inf);
 }
 
+bool add::is_polynomial(const ex & var) const
+{
+       for (epvector::const_iterator i=seq.begin(); i!=seq.end(); ++i) {
+               if (!(i->rest).is_polynomial(var)) {
+                       return false;
+               }
+       }
+       return true;
+}
+
 int add::degree(const ex & s) const
 {
        int deg = std::numeric_limits<int>::min();
@@ -297,7 +308,7 @@ ex add::coeff(const ex & s, int n) const
 {
        std::auto_ptr<epvector> coeffseq(new epvector);
        std::auto_ptr<epvector> coeffseq_cliff(new epvector);
-       char rl = clifford_max_label(s);
+       int rl = clifford_max_label(s);
        bool do_clifford = (rl != -1);
        bool nonscalar = false;
 
@@ -305,14 +316,14 @@ ex add::coeff(const ex & s, int n) const
        epvector::const_iterator i = seq.begin(), end = seq.end();
        while (i != end) {
                ex restcoeff = i->rest.coeff(s, n);
-               if (!restcoeff.is_zero()) {
-                       if (do_clifford) {
-                               if (clifford_max_label(restcoeff) == -1) {
-                                       coeffseq_cliff->push_back(combine_ex_with_coeff_to_pair(ncmul(restcoeff, dirac_ONE(rl)), i->coeff));
+               if (!restcoeff.is_zero()) {
+                       if (do_clifford) {
+                               if (clifford_max_label(restcoeff) == -1) {
+                                       coeffseq_cliff->push_back(combine_ex_with_coeff_to_pair(ncmul(restcoeff, dirac_ONE(rl)), i->coeff));
                                } else {
-                                       coeffseq_cliff->push_back(combine_ex_with_coeff_to_pair(restcoeff, i->coeff));
+                                       coeffseq_cliff->push_back(combine_ex_with_coeff_to_pair(restcoeff, i->coeff));
                                        nonscalar = true;
-                               }
+                               }
                        }
                        coeffseq->push_back(combine_ex_with_coeff_to_pair(restcoeff, i->coeff));
                }
@@ -333,7 +344,7 @@ ex add::coeff(const ex & s, int n) const
 ex add::eval(int level) const
 {
        std::auto_ptr<epvector> evaled_seqp = evalchildren(level);
-       if (evaled_seqp.get()) {
+       if (unlikely(evaled_seqp.get() != 0)) {
                // do more evaluation later
                return (new add(evaled_seqp, overall_coeff))->
                       setflag(status_flags::dynallocated);
@@ -343,9 +354,6 @@ ex add::eval(int level) const
        epvector::const_iterator i = seq.begin(), end = seq.end();
        while (i != end) {
                GINAC_ASSERT(!is_exactly_a<add>(i->rest));
-               if (is_exactly_a<numeric>(i->rest))
-                       dbgprint();
-               GINAC_ASSERT(!is_exactly_a<numeric>(i->rest));
                ++i;
        }
 #endif // def DO_GINAC_ASSERT
@@ -366,6 +374,33 @@ ex add::eval(int level) const
        } else if (!overall_coeff.is_zero() && seq[0].rest.return_type() != return_types::commutative) {
                throw (std::logic_error("add::eval(): sum of non-commutative objects has non-zero numeric term"));
        }
+       
+       // if any terms in the sum still are purely numeric, then they are more
+       // appropriately collected into the overall coefficient
+       epvector::const_iterator last = seq.end();
+       epvector::const_iterator j = seq.begin();
+       int terms_to_collect = 0;
+       while (j != last) {
+               if (unlikely(is_a<numeric>(j->rest)))
+                       ++terms_to_collect;
+               ++j;
+       }
+       if (terms_to_collect) {
+               std::auto_ptr<epvector> s(new epvector);
+               s->reserve(seq_size - terms_to_collect);
+               numeric oc = *_num0_p;
+               j = seq.begin();
+               while (j != last) {
+                       if (unlikely(is_a<numeric>(j->rest)))
+                               oc = oc.add(ex_to<numeric>(j->rest).mul(ex_to<numeric>(j->coeff)));
+                       else
+                               s->push_back(*j);
+                       ++j;
+               }
+               return (new add(s, ex_to<numeric>(overall_coeff).add_dyn(oc)))
+                       ->setflag(status_flags::dynallocated);
+       }
+       
        return this->hold();
 }
 
@@ -529,6 +564,8 @@ expair add::split_ex_to_pair(const ex & e) const
        if (is_exactly_a<mul>(e)) {
                const mul &mulref(ex_to<mul>(e));
                const ex &numfactor = mulref.overall_coeff;
+               if (numfactor.is_equal(_ex1))
+                       return expair(e, _ex1);
                mul *mulcopyp = new mul(mulref);
                mulcopyp->overall_coeff = _ex1;
                mulcopyp->clearflag(status_flags::evaluated);
@@ -540,12 +577,14 @@ expair add::split_ex_to_pair(const ex & e) const
 }
 
 expair add::combine_ex_with_coeff_to_pair(const ex & e,
-                                                                                 const ex & c) const
+                                          const ex & c) const
 {
        GINAC_ASSERT(is_exactly_a<numeric>(c));
        if (is_exactly_a<mul>(e)) {
                const mul &mulref(ex_to<mul>(e));
                const ex &numfactor = mulref.overall_coeff;
+               if (numfactor.is_equal(_ex1))
+                       return expair(e, c);
                mul *mulcopyp = new mul(mulref);
                mulcopyp->overall_coeff = _ex1;
                mulcopyp->clearflag(status_flags::evaluated);
@@ -553,20 +592,20 @@ expair add::combine_ex_with_coeff_to_pair(const ex & e,
                mulcopyp->setflag(status_flags::dynallocated);
                if (c.is_equal(_ex1))
                        return expair(*mulcopyp, numfactor);
-               else if (numfactor.is_equal(_ex1))
-                       return expair(*mulcopyp, c);
                else
                        return expair(*mulcopyp, ex_to<numeric>(numfactor).mul_dyn(ex_to<numeric>(c)));
        } else if (is_exactly_a<numeric>(e)) {
                if (c.is_equal(_ex1))
                        return expair(e, _ex1);
+               if (e.is_equal(_ex1))
+                       return expair(c, _ex1);
                return expair(ex_to<numeric>(e).mul_dyn(ex_to<numeric>(c)), _ex1);
        }
        return expair(e, c);
 }
 
 expair add::combine_pair_with_coeff_to_pair(const expair & p,
-                                                                                       const ex & c) const
+                                            const ex & c) const
 {
        GINAC_ASSERT(is_exactly_a<numeric>(p.coeff));
        GINAC_ASSERT(is_exactly_a<numeric>(c));
@@ -578,7 +617,7 @@ expair add::combine_pair_with_coeff_to_pair(const expair & p,
 
        return expair(p.rest,ex_to<numeric>(p.coeff).mul_dyn(ex_to<numeric>(c)));
 }
-       
+
 ex add::recombine_pair_to_ex(const expair & p) const
 {
        if (ex_to<numeric>(p.coeff).is_equal(*_num1_p))