* Implementation of GiNaC's products of expressions. */
/*
- * GiNaC Copyright (C) 1999-2015 Johannes Gutenberg University Mainz, Germany
+ * GiNaC Copyright (C) 1999-2017 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
GINAC_ASSERT(is_canonical());
}
+mul::mul(epvector && vp)
+{
+ overall_coeff = _ex1;
+ construct_from_epvector(std::move(vp));
+ GINAC_ASSERT(is_canonical());
+}
+
mul::mul(epvector && vp, const ex & oc, bool do_index_renaming)
{
overall_coeff = oc;
return true;
return overall_coeff.info(inf);
}
- case info_flags::algebraic: {
- for (auto & it : seq) {
- if (recombine_pair_to_ex(it).info(inf))
- return true;
- }
- return false;
- }
case info_flags::positive:
case info_flags::negative: {
if ((inf==info_flags::positive) && (flags & status_flags::is_positive))
return this->hold();
}
-ex mul::evalf(int level) const
+ex mul::evalf() const
{
- if (level==1)
- return mul(seq, overall_coeff);
-
- if (level==-max_recursion_level)
- throw(std::runtime_error("max recursion level reached"));
-
epvector s;
s.reserve(seq.size());
- --level;
- for (auto & it : seq) {
- s.push_back(expair(it.rest.evalf(level), it.coeff));
- }
- return dynallocate<mul>(std::move(s), overall_coeff.evalf(level));
+ for (auto & it : seq)
+ s.push_back(expair(it.rest.evalf(), it.coeff));
+ return dynallocate<mul>(std::move(s), overall_coeff.evalf());
}
void mul::find_real_imag(ex & rp, ex & ip) const
if (is_exactly_a<symbol>(e))
return expair(e, c);
+ // trivial case: exponent 1
+ if (c.is_equal(_ex1))
+ return split_ex_to_pair(e);
+
// to avoid duplication of power simplification rules,
// we create a temporary power object
// otherwise it would be hard to correctly evaluate
// expression like (4^(1/3))^(3/2)
- if (c.is_equal(_ex1))
- return split_ex_to_pair(e);
-
return split_ex_to_pair(pow(e,c));
}
GINAC_ASSERT(is_exactly_a<numeric>(p.coeff));
GINAC_ASSERT(is_exactly_a<numeric>(c));
+ // First, try a common shortcut:
+ if (is_exactly_a<symbol>(p.rest))
+ return expair(p.rest, p.coeff * c);
+
+ // trivial case: exponent 1
+ if (c.is_equal(_ex1))
+ return p;
+ if (p.coeff.is_equal(_ex1))
+ return expair(p.rest, c);
+
// to avoid duplication of power simplification rules,
// we create a temporary power object
// otherwise it would be hard to correctly evaluate
// expression like (4^(1/3))^(3/2)
- if (c.is_equal(_ex1))
- return p;
-
return split_ex_to_pair(pow(recombine_pair_to_ex(p),c));
}
ex mul::recombine_pair_to_ex(const expair & p) const
{
- if (ex_to<numeric>(p.coeff).is_equal(*_num1_p))
+ if (p.coeff.is_equal(_ex1))
return p.rest;
else
return dynallocate<power>(p.rest, p.coeff);