* 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))
GINAC_ASSERT(is_canonical());
}
-mul::mul(epvector * vp, const ex & oc)
+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);
- delete vp;
GINAC_ASSERT(is_canonical());
}
* @param level cut-off in recursive evaluation */
ex mul::eval(int level) const
{
- epvector *evaled_seqp = evalchildren(level);
- if (evaled_seqp) {
+ std::auto_ptr<epvector> evaled_seqp = evalchildren(level);
+ if (evaled_seqp.get()) {
// do more evaluation later
- return (new mul(evaled_seqp,overall_coeff))->
+ return (new mul(evaled_seqp, overall_coeff))->
setflag(status_flags::dynallocated);
}
ex_to<numeric>((*seq.begin()).coeff).is_equal(_num1)) {
// *(+(x,y,...);c) -> +(*(x,c),*(y,c),...) (c numeric(), no powers of +())
const add & addref = ex_to<add>((*seq.begin()).rest);
- epvector *distrseq = new epvector();
+ std::auto_ptr<epvector> distrseq(new epvector);
distrseq->reserve(addref.seq.size());
epvector::const_iterator i = addref.seq.begin(), end = addref.seq.end();
while (i != end) {
if (level==-max_recursion_level)
throw(std::runtime_error("max recursion level reached"));
- epvector *s = new epvector();
+ std::auto_ptr<epvector> s(new epvector);
s->reserve(seq.size());
--level;
// Evaluate children first, look whether there are any matrices at all
// (there can be either no matrices or one matrix; if there were more
// than one matrix, it would be a non-commutative product)
- epvector *s = new epvector;
+ std::auto_ptr<epvector> s(new epvector);
s->reserve(seq.size());
bool have_matrix = false;
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 (new mul(v, oc))->setflag(status_flags::dynallocated);
}
-ex mul::thisexpairseq(epvector * vp, const ex & oc) const
+ex mul::thisexpairseq(std::auto_ptr<epvector> vp, const ex & oc) const
{
return (new mul(vp, oc))->setflag(status_flags::dynallocated);
}
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
- epvector * expanded_seqp = expandchildren(options);
- const epvector & expanded_seq = (expanded_seqp == NULL) ? seq : *expanded_seqp;
+ std::auto_ptr<epvector> expanded_seqp = expandchildren(options);
+ const epvector & expanded_seq = (expanded_seqp.get() ? *expanded_seqp : seq);
// 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;
}
- if (expanded_seqp)
- delete expanded_seqp;
-
+
// 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;
+ }
}
* @see mul::expand()
* @return pointer to epvector containing expanded representation or zero
* pointer, if sequence is unchanged. */
-epvector * mul::expandchildren(unsigned options) const
+std::auto_ptr<epvector> mul::expandchildren(unsigned options) const
{
const epvector::const_iterator last = seq.end();
epvector::const_iterator cit = seq.begin();
if (!are_ex_trivially_equal(factor,expanded_factor)) {
// something changed, copy seq, eval and return it
- epvector *s = new epvector;
+ std::auto_ptr<epvector> s(new epvector);
s->reserve(seq.size());
// copy parts of seq which are known not to have changed
s->push_back(*cit2);
++cit2;
}
+
// copy first changed element
s->push_back(split_ex_to_pair(expanded_factor));
++cit2;
+
// copy rest
while (cit2!=last) {
s->push_back(split_ex_to_pair(recombine_pair_to_ex(*cit2).expand(options)));
++cit;
}
- return 0; // nothing has changed
+ return std::auto_ptr<epvector>(0); // nothing has changed
}
} // namespace GiNaC
git://www.ginac.de / ginac.git / blobdiff