some more comments and cleanups to mul::expand() and ncmul::expand()

diff --git a/ginac/add.cpp b/ginac/add.cpp
index 5a4c805d4373d952dd3aab0712734e1ec2f635d9..7764d3683fb5e97a0ccb618b71fcfe9aa7ea2cd3 100644 (file)
--- a/ginac/add.cpp
+++ b/ginac/add.cpp
@@ -511,9 +511,6 @@ ex add::recombine_pair_to_ex(const expair & p) const
 
 ex add::expand(unsigned options) const
 {
-       if (options == 0 && (flags & status_flags::expanded))
-               return *this;
-       
        epvector *vp = expandchildren(options);
        if (vp == NULL) {
                // the terms have not changed, so it is safe to declare this expanded

diff --git a/ginac/expairseq.cpp b/ginac/expairseq.cpp
index a18927c26e69933a485f7ddaa2aca91e42acc0c7..f49fefcf208495ddf3a9d9d78f8a744bebf36092 100644 (file)
--- a/ginac/expairseq.cpp
+++ b/ginac/expairseq.cpp
@@ -311,7 +311,10 @@ ex expairseq::map(map_function & f) const
                ++cit;
        }
 
-       return thisexpairseq(v, f(overall_coeff));
+       if (overall_coeff.is_equal(default_overall_coeff()))
+               return thisexpairseq(v, default_overall_coeff());
+       else
+               return thisexpairseq(v, f(overall_coeff));
 }
 
 ex expairseq::eval(int level) const

diff --git a/ginac/mul.cpp b/ginac/mul.cpp
index 2cb358efbfda50ea736fc816511069854a77eccb..92e21b3efa4c427f37e2d949a92185eef1d8aaf4 100644 (file)
--- a/ginac/mul.cpp
+++ b/ginac/mul.cpp
@@ -668,42 +668,39 @@ bool mul::can_make_flat(const expair & p) const
 
 ex mul::expand(unsigned options) const
 {
-       if (options == 0 && (flags & status_flags::expanded))
-               return *this;
-       
-       exvector sub_expanded_seq;
-       
+       // First, expand the children
        epvector * expanded_seqp = expandchildren(options);
-       
-       const epvector & expanded_seq = expanded_seqp==0 ? seq : *expanded_seqp;
-       
+       const epvector & expanded_seq = (expanded_seqp == NULL) ? seq : *expanded_seqp;
+
+       // Now, look for all the factors that are sums and multiply each one out
+       // with the next one that is found while collecting the factors which are
+       // not sums
        int number_of_adds = 0;
+       ex last_expanded = _ex1();
        epvector non_adds;
        non_adds.reserve(expanded_seq.size());
-       epvector::const_iterator cit = expanded_seq.begin();
-       epvector::const_iterator last = expanded_seq.end();
-       ex last_expanded = _ex1();
-       while (cit!=last) {
-               if (is_ex_exactly_of_type((*cit).rest,add) &&
-                       ((*cit).coeff.is_equal(_ex1()))) {
+       epvector::const_iterator cit = expanded_seq.begin(), last = expanded_seq.end();
+       while (cit != last) {
+               if (is_ex_exactly_of_type(cit->rest, add) &&
+                       (cit->coeff.is_equal(_ex1()))) {
                        ++number_of_adds;
-                       if (is_ex_exactly_of_type(last_expanded,add)) {
-                               // expand adds
+                       if (is_ex_exactly_of_type(last_expanded, add)) {
                                const add & add1 = ex_to<add>(last_expanded);
-                               const add & add2 = ex_to<add>((*cit).rest);
+                               const add & add2 = ex_to<add>(cit->rest);
                                int n1 = add1.nops();
                                int n2 = add2.nops();
                                exvector distrseq;
                                distrseq.reserve(n1*n2);
                                for (int i1=0; i1<n1; ++i1) {
                                        for (int i2=0; i2<n2; ++i2) {
-                                               distrseq.push_back(add1.op(i1)*add2.op(i2));
+                                               distrseq.push_back(add1.op(i1) * add2.op(i2));
                                        }
                                }
-                               last_expanded = (new add(distrseq))->setflag(status_flags::dynallocated | (options == 0 ? status_flags::expanded : 0));
+                               last_expanded = (new add(distrseq))->
+                                                setflag(status_flags::dynallocated | (options == 0 ? status_flags::expanded : 0));
                        } else {
                                non_adds.push_back(split_ex_to_pair(last_expanded));
-                               last_expanded = (*cit).rest;
+                               last_expanded = cit->rest;
                        }
                } else {
                        non_adds.push_back(*cit);
@@ -713,7 +710,9 @@ ex mul::expand(unsigned options) const
        if (expanded_seqp)
                delete expanded_seqp;
 
-       if (is_ex_exactly_of_type(last_expanded,add)) {
+       // Now the only remaining thing to do is to multiply the factors which
+       // were not sums into the "last_expanded" sum
+       if (is_ex_exactly_of_type(last_expanded, add)) {
                add const & finaladd = ex_to<add>(last_expanded);
                exvector distrseq;
                int n = finaladd.nops();
@@ -721,7 +720,8 @@ ex mul::expand(unsigned options) const
                for (int i=0; i<n; ++i) {
                        epvector factors = non_adds;
                        factors.push_back(split_ex_to_pair(finaladd.op(i)));
-                       distrseq.push_back((new mul(factors,overall_coeff))->setflag(status_flags::dynallocated | (options == 0 ? status_flags::expanded : 0)));
+                       distrseq.push_back((new mul(factors, overall_coeff))->
+                                           setflag(status_flags::dynallocated | (options == 0 ? status_flags::expanded : 0)));
                }
                return ((new add(distrseq))->
                        setflag(status_flags::dynallocated | (options == 0 ? status_flags::expanded : 0)));

diff --git a/ginac/ncmul.cpp b/ginac/ncmul.cpp
index 25ffca31d45023f63eaf45374f3002c29714d94d..c4cfe69cb2a93fd3b8afe03f2e571c9a1ba0e34e 100644 (file)
--- a/ginac/ncmul.cpp
+++ b/ginac/ncmul.cpp
@@ -147,69 +147,69 @@ typedef std::vector<int> intvector;
 
 ex ncmul::expand(unsigned options) const
 {
-       exvector sub_expanded_seq;
-       intvector positions_of_adds;
-       intvector number_of_add_operands;
-
-       exvector expanded_seq=expandchildren(options);
-
-       positions_of_adds.resize(expanded_seq.size());
-       number_of_add_operands.resize(expanded_seq.size());
-
-       int number_of_adds=0;
-       int number_of_expanded_terms=1;
-
-       unsigned current_position=0;
-       exvector::const_iterator last=expanded_seq.end();
+       // First, expand the children
+       exvector expanded_seq = expandchildren(options);
+
+       // Now, look for all the factors that are sums and remember their
+       // position and number of terms. One remark is in order here: we do not
+       // take into account the overall_coeff of the add objects. This is
+       // because in GiNaC, all terms of a sum must be of the same type, so
+       // a non-zero overall_coeff (which can only be numeric) would imply that
+       // the sum only has commutative terms. But then it would never appear
+       // as a factor of an ncmul.
+       intvector positions_of_adds(expanded_seq.size());
+       intvector number_of_add_operands(expanded_seq.size());
+
+       int number_of_adds = 0;
+       int number_of_expanded_terms = 1;
+
+       unsigned current_position = 0;
+       exvector::const_iterator last = expanded_seq.end();
        for (exvector::const_iterator cit=expanded_seq.begin(); cit!=last; ++cit) {
-               if (is_ex_exactly_of_type((*cit),add)) {
-                       positions_of_adds[number_of_adds]=current_position;
-                       const add & expanded_addref=ex_to<add>(*cit);
-                       number_of_add_operands[number_of_adds]=expanded_addref.seq.size();
+               if (is_ex_exactly_of_type(*cit, add)) {
+                       positions_of_adds[number_of_adds] = current_position;
+                       const add & expanded_addref = ex_to<add>(*cit);
+                       number_of_add_operands[number_of_adds] = expanded_addref.seq.size();
                        number_of_expanded_terms *= expanded_addref.seq.size();
                        number_of_adds++;
                }
                current_position++;
        }
 
-       if (number_of_adds==0) {
-               return (new ncmul(expanded_seq,1))->setflag(status_flags::dynallocated ||
-                                                                                                       (options == 0 ? status_flags::expanded : 0));
-       }
+       // If there are no sums, we are done
+       if (number_of_adds == 0)
+               return (new ncmul(expanded_seq, true))->
+                       setflag(status_flags::dynallocated | (options == 0 ? status_flags::expanded : 0));
 
+       // Now, form all possible products of the terms of the sums with the
+       // remaining factors, and add them together
        exvector distrseq;
        distrseq.reserve(number_of_expanded_terms);
 
-       intvector k;
-       k.resize(number_of_adds);
-       
-       int l;
-       for (l=0; l<number_of_adds; l++) {
-               k[l]=0;
-       }
+       intvector k(number_of_adds);
 
-       while (1) {
-               exvector term;
-               term=expanded_seq;
-               for (l=0; l<number_of_adds; l++) {
-                       GINAC_ASSERT(is_ex_exactly_of_type(expanded_seq[positions_of_adds[l]],add));
-                       const add & addref=ex_to<add>(expanded_seq[positions_of_adds[l]]);
-                       term[positions_of_adds[l]]=addref.recombine_pair_to_ex(addref.seq[k[l]]);
+       while (true) {
+               exvector term = expanded_seq;
+               for (int i=0; i<number_of_adds; i++) {
+                       GINAC_ASSERT(is_ex_exactly_of_type(expanded_seq[positions_of_adds[i]], add));
+                       const add & addref = ex_to<add>(expanded_seq[positions_of_adds[i]]);
+                       term[positions_of_adds[i]] = addref.recombine_pair_to_ex(addref.seq[k[i]]);
                }
-               distrseq.push_back((new ncmul(term,1))->setflag(status_flags::dynallocated |
-                                                                                                               (options == 0 ? status_flags::expanded : 0)));
+               distrseq.push_back((new ncmul(term, true))->
+                                   setflag(status_flags::dynallocated | (options == 0 ? status_flags::expanded : 0)));
 
                // increment k[]
-               l=number_of_adds-1;
-               while ((l>=0)&&((++k[l])>=number_of_add_operands[l])) {
-                       k[l]=0;    
+               int l = number_of_adds-1;
+               while ((l>=0) && ((++k[l]) >= number_of_add_operands[l])) {
+                       k[l] = 0;
                        l--;
                }
-               if (l<0) break;
+               if (l<0)
+                       break;
        }
 
-       return (new add(distrseq))->setflag(status_flags::dynallocated |
-                                                                               (options == 0 ? status_flags::expanded : 0));
+       return (new add(distrseq))->
+               setflag(status_flags::dynallocated | (options == 0 ? status_flags::expanded : 0));
 }
 
 int ncmul::degree(const ex & s) const