* Implementation of GiNaC's products of expressions. */
/*
- * GiNaC Copyright (C) 1999-2003 Johannes Gutenberg University Mainz, Germany
+ * GiNaC Copyright (C) 1999-2004 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
print_func<print_context>(&mul::do_print).
print_func<print_latex>(&mul::do_print_latex).
print_func<print_csrc>(&mul::do_print_csrc).
- print_func<print_tree>(&inherited::do_print_tree).
+ print_func<print_tree>(&mul::do_print_tree).
print_func<print_python_repr>(&mul::do_print_python_repr))
mul::mul(std::auto_ptr<epvector> vp, const ex & oc)
{
tinfo_key = TINFO_mul;
- GINAC_ASSERT(vp!=0);
+ GINAC_ASSERT(vp.get()!=0);
overall_coeff = oc;
construct_from_epvector(*vp);
GINAC_ASSERT(is_canonical());
unsigned mul::return_type() const
{
if (seq.empty()) {
- // mul without factors: should not happen, but commutes
+ // mul without factors: should not happen, but commutates
return return_types::commutative;
}
return ex_to<numeric>(p.coeff).is_equal(_num1);
}
+bool mul::can_be_further_expanded(const ex & e)
+{
+ if (is_exactly_a<mul>(e)) {
+ for (epvector::const_iterator cit = ex_to<mul>(e).seq.begin(); cit != ex_to<mul>(e).seq.end(); ++cit) {
+ if (is_exactly_a<add>(cit->rest) && cit->coeff.info(info_flags::posint))
+ return true;
+ }
+ } else if (is_exactly_a<power>(e)) {
+ if (is_exactly_a<add>(e.op(0)) && e.op(1).info(info_flags::posint))
+ return true;
+ }
+ return false;
+}
+
ex mul::expand(unsigned options) const
{
// First, expand the children
// 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());
- 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<add>(cit->rest) &&
(cit->coeff.is_equal(_ex1))) {
- ++number_of_adds;
if (is_exactly_a<add>(last_expanded)) {
// Expand a product of two sums, aggressive version.
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))
for (epvector::const_iterator i=add2begin; i!=add2end; ++i)
distrseq.push_back(expair(i->rest, ex_to<numeric>(i->coeff).mul_dyn(ex_to<numeric>(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))
for (epvector::const_iterator i=add1begin; i!=add1end; ++i)
distrseq.push_back(expair(i->rest, ex_to<numeric>(i->coeff).mul_dyn(ex_to<numeric>(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
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 {
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<add>(last_expanded)) {
- const add & finaladd = ex_to<add>(last_expanded);
+ size_t n = last_expanded.nops();
exvector distrseq;
- size_t n = finaladd.nops();
distrseq.reserve(n);
+
for (size_t 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)));
+ 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<basic>(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<basic>(result).setflag(status_flags::expanded);
+ return result;
+ }
}
git://www.ginac.de / ginac.git / blobdiff