+ for (auto & it : seq) {
+ s.push_back(combine_ex_with_coeff_to_pair(it.rest.evalf(level),
+ it.coeff));
+ }
+ return mul(std::move(s), overall_coeff.evalf(level));
+}
+
+void mul::find_real_imag(ex & rp, ex & ip) const
+{
+ rp = overall_coeff.real_part();
+ ip = overall_coeff.imag_part();
+ for (auto & it : seq) {
+ ex factor = recombine_pair_to_ex(it);
+ ex new_rp = factor.real_part();
+ ex new_ip = factor.imag_part();
+ if (new_ip.is_zero()) {
+ rp *= new_rp;
+ ip *= new_rp;
+ } else {
+ ex temp = rp*new_rp - ip*new_ip;
+ ip = ip*new_rp + rp*new_ip;
+ rp = temp;
+ }
+ }
+ rp = rp.expand();
+ ip = ip.expand();
+}
+
+ex mul::real_part() const
+{
+ ex rp, ip;
+ find_real_imag(rp, ip);
+ return rp;
+}
+
+ex mul::imag_part() const
+{
+ ex rp, ip;
+ find_real_imag(rp, ip);
+ return ip;
+}
+
+ex mul::evalm() const
+{
+ // numeric*matrix
+ if (seq.size() == 1 && seq[0].coeff.is_equal(_ex1)
+ && is_a<matrix>(seq[0].rest))
+ return ex_to<matrix>(seq[0].rest).mul(ex_to<numeric>(overall_coeff));
+
+ // 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;
+ s.reserve(seq.size());
+
+ bool have_matrix = false;
+ epvector::iterator the_matrix;
+
+ for (auto & it : seq) {
+ const ex &m = recombine_pair_to_ex(it).evalm();
+ s.push_back(split_ex_to_pair(m));
+ if (is_a<matrix>(m)) {
+ have_matrix = true;
+ the_matrix = s.end() - 1;
+ }
+ }
+
+ if (have_matrix) {
+
+ // The product contained a matrix. We will multiply all other factors
+ // into that matrix.
+ matrix m = ex_to<matrix>(the_matrix->rest);
+ s.erase(the_matrix);
+ ex scalar = (new mul(std::move(s), overall_coeff))->setflag(status_flags::dynallocated);
+ return m.mul_scalar(scalar);
+
+ } else
+ return (new mul(std::move(s), overall_coeff))->setflag(status_flags::dynallocated);
+}
+
+ex mul::eval_ncmul(const exvector & v) const
+{
+ if (seq.empty())
+ return inherited::eval_ncmul(v);
+
+ // Find first noncommutative element and call its eval_ncmul()
+ for (auto & it : seq)
+ if (it.rest.return_type() == return_types::noncommutative)
+ return it.rest.eval_ncmul(v);
+ return inherited::eval_ncmul(v);
+}
+
+bool tryfactsubs(const ex & origfactor, const ex & patternfactor, int & nummatches, exmap& repls)
+{
+ ex origbase;
+ int origexponent;
+ int origexpsign;
+
+ if (is_exactly_a<power>(origfactor) && origfactor.op(1).info(info_flags::integer)) {
+ origbase = origfactor.op(0);
+ int expon = ex_to<numeric>(origfactor.op(1)).to_int();
+ origexponent = expon > 0 ? expon : -expon;
+ origexpsign = expon > 0 ? 1 : -1;
+ } else {
+ origbase = origfactor;
+ origexponent = 1;
+ origexpsign = 1;
+ }
+
+ ex patternbase;
+ int patternexponent;
+ int patternexpsign;
+
+ if (is_exactly_a<power>(patternfactor) && patternfactor.op(1).info(info_flags::integer)) {
+ patternbase = patternfactor.op(0);
+ int expon = ex_to<numeric>(patternfactor.op(1)).to_int();
+ patternexponent = expon > 0 ? expon : -expon;
+ patternexpsign = expon > 0 ? 1 : -1;
+ } else {
+ patternbase = patternfactor;
+ patternexponent = 1;
+ patternexpsign = 1;