From 49ea4a7016c15b69d394d687b3738f2c128bb41d Mon Sep 17 00:00:00 2001 From: Christian Bauer Date: Thu, 18 Dec 2003 18:33:01 +0000 Subject: [PATCH] some attempts to squeeze performance out of mul::expand() --- ginac/mul.cpp | 71 +++++++++++++++++++++++++++++++-------------------- ginac/mul.h | 1 + 2 files changed, 45 insertions(+), 27 deletions(-) diff --git a/ginac/mul.cpp b/ginac/mul.cpp index db68b275..3eccef9c 100644 --- a/ginac/mul.cpp +++ b/ginac/mul.cpp @@ -824,6 +824,20 @@ bool mul::can_make_flat(const expair & p) const return ex_to(p.coeff).is_equal(_num1); } +bool mul::can_be_further_expanded(const ex & e) +{ + if (is_exactly_a(e)) { + for (epvector::const_iterator cit = ex_to(e).seq.begin(); cit != ex_to(e).seq.end(); ++cit) { + if (is_exactly_a(cit->rest) && cit->coeff.info(info_flags::posint)) + return true; + } + } else if (is_exactly_a(e)) { + if (is_exactly_a(e.op(0)) && e.op(1).info(info_flags::posint)) + return true; + } + return false; +} + ex mul::expand(unsigned options) const { // First, expand the children @@ -833,18 +847,15 @@ ex mul::expand(unsigned options) const // 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; + bool need_reexpand = false; epvector non_adds; non_adds.reserve(expanded_seq.size()); - bool non_adds_has_sums = false; // Look for sums or powers of sums in the non_adds (we need this later) - epvector::const_iterator cit = expanded_seq.begin(), last = expanded_seq.end(); - while (cit != last) { + for (epvector::const_iterator cit = expanded_seq.begin(); cit != expanded_seq.end(); ++cit) { if (is_exactly_a(cit->rest) && (cit->coeff.is_equal(_ex1))) { - ++number_of_adds; if (is_exactly_a(last_expanded)) { // Expand a product of two sums, aggressive version. @@ -862,6 +873,7 @@ ex mul::expand(unsigned options) const const epvector::const_iterator add2end = add2.seq.end(); epvector distrseq; distrseq.reserve(add1.seq.size()+add2.seq.size()); + // Multiply add2 with the overall coefficient of add1 and append it to distrseq: if (!add1.overall_coeff.is_zero()) { if (add1.overall_coeff.is_equal(_ex1)) @@ -870,6 +882,7 @@ ex mul::expand(unsigned options) const for (epvector::const_iterator i=add2begin; i!=add2end; ++i) distrseq.push_back(expair(i->rest, ex_to(i->coeff).mul_dyn(ex_to(add1.overall_coeff)))); } + // Multiply add1 with the overall coefficient of add2 and append it to distrseq: if (!add2.overall_coeff.is_zero()) { if (add2.overall_coeff.is_equal(_ex1)) @@ -878,8 +891,10 @@ ex mul::expand(unsigned options) const for (epvector::const_iterator i=add1begin; i!=add1end; ++i) distrseq.push_back(expair(i->rest, ex_to(i->coeff).mul_dyn(ex_to(add2.overall_coeff)))); } + // Compute the new overall coefficient and put it together: ex tmp_accu = (new add(distrseq, add1.overall_coeff*add2.overall_coeff))->setflag(status_flags::dynallocated); + // Multiply explicitly all non-numeric terms of add1 and add2: for (epvector::const_iterator i1=add1begin; i1!=add1end; ++i1) { // We really have to combine terms here in order to compactify @@ -889,7 +904,7 @@ ex mul::expand(unsigned options) const for (epvector::const_iterator i2=add2begin; i2!=add2end; ++i2) { // Don't push_back expairs which might have a rest that evaluates to a numeric, // since that would violate an invariant of expairseq: - const ex rest = ex((new mul(i1->rest, i2->rest))->setflag(status_flags::dynallocated)).expand(); + const ex rest = (new mul(i1->rest, i2->rest))->setflag(status_flags::dynallocated); if (is_exactly_a(rest)) oc += ex_to(rest).mul(ex_to(i1->coeff).mul(ex_to(i2->coeff))); else @@ -900,47 +915,49 @@ ex mul::expand(unsigned options) const last_expanded = tmp_accu; } else { - non_adds.push_back(split_ex_to_pair(last_expanded)); + if (!last_expanded.is_equal(_ex1)) + non_adds.push_back(split_ex_to_pair(last_expanded)); last_expanded = cit->rest; } + } else { - if (is_exactly_a(cit->rest)) - non_adds_has_sums = true; non_adds.push_back(*cit); } - ++cit; } // Now the only remaining thing to do is to multiply the factors which // were not sums into the "last_expanded" sum if (is_exactly_a(last_expanded)) { - const add & finaladd = ex_to(last_expanded); - - size_t n = finaladd.nops(); + size_t n = last_expanded.nops(); exvector distrseq; distrseq.reserve(n); for (size_t i=0; i((new mul(factors, overall_coeff))->setflag(status_flags::dynallocated)); - - // The new term may have sums in it if e.g. a sqrt() of a sum in - // the non_adds meets a sqrt() of a sum in the factor from - // last_expanded. In this case we should re-expand the term. - if (non_adds_has_sums || is_exactly_a(new_factor.rest)) - distrseq.push_back(ex(term).expand()); - else - distrseq.push_back(term.setflag(options == 0 ? status_flags::expanded : 0)); + factors.push_back(split_ex_to_pair(last_expanded.op(i))); + ex term = (new mul(factors, overall_coeff))->setflag(status_flags::dynallocated); + if (can_be_further_expanded(term)) + distrseq.push_back(term.expand()); + else { + if (options == 0) + ex_to(term).setflag(status_flags::expanded); + distrseq.push_back(term); + } } + return ((new add(distrseq))-> setflag(status_flags::dynallocated | (options == 0 ? status_flags::expanded : 0))); } + non_adds.push_back(split_ex_to_pair(last_expanded)); - return (new mul(non_adds, overall_coeff))-> - setflag(status_flags::dynallocated | (options == 0 ? status_flags::expanded : 0)); + ex result = (new mul(non_adds, overall_coeff))->setflag(status_flags::dynallocated); + if (can_be_further_expanded(result)) { + return result.expand(); + } else { + if (options == 0) + ex_to(result).setflag(status_flags::expanded); + return result; + } } diff --git a/ginac/mul.h b/ginac/mul.h index 25c48f4f..27844683 100644 --- a/ginac/mul.h +++ b/ginac/mul.h @@ -91,6 +91,7 @@ protected: void do_print_latex(const print_latex & c, unsigned level) const; void do_print_csrc(const print_csrc & c, unsigned level) const; void do_print_python_repr(const print_python_repr & c, unsigned level) const; + static bool can_be_further_expanded(const ex & e); std::auto_ptr expandchildren(unsigned options) const; }; -- 2.44.0