#include "mul.h"
#include "add.h"
#include "power.h"
+#include "matrix.h"
#include "archive.h"
#include "debugmsg.h"
#include "utils.h"
} else if (is_of_type(c, print_csrc)) {
- if (precedence <= level)
+ if (precedence() <= level)
c.s << "(";
if (!overall_coeff.is_equal(_ex1())) {
- overall_coeff.bp->print(c, precedence);
+ overall_coeff.bp->print(c, precedence());
c.s << "*";
}
-
+
// Print arguments, separated by "*" or "/"
epvector::const_iterator it = seq.begin(), itend = seq.end();
while (it != itend) {
// If the exponent is 1 or -1, it is left out
if (it->coeff.compare(_ex1()) == 0 || it->coeff.compare(_num_1()) == 0)
- it->rest.print(c, precedence);
+ it->rest.print(c, precedence());
else {
// Outer parens around ex needed for broken gcc-2.95 parser:
(ex(power(it->rest, abs(ex_to_numeric(it->coeff))))).print(c, level);
}
}
- if (precedence <= level)
+ if (precedence() <= level)
c.s << ")";
} else {
- if (precedence <= level)
- c.s << "(";
+ if (precedence() <= level) {
+ if (is_of_type(c, print_latex))
+ c.s << "{(";
+ else
+ c.s << "(";
+ }
bool first = true;
!coeff.is_equal(_num_1())) {
if (coeff.is_rational()) {
if (coeff.is_negative())
- (-coeff).print(c, precedence);
+ (-coeff).print(c);
else
- coeff.print(c, precedence);
+ coeff.print(c);
} else {
if (coeff.csgn() == -1)
- (-coeff).print(c, precedence);
+ (-coeff).print(c, precedence());
else
- coeff.print(c, precedence);
+ coeff.print(c, precedence());
}
- c.s << '*';
+ if (is_of_type(c, print_latex))
+ c.s << ' ';
+ else
+ c.s << '*';
}
// Then proceed with the remaining factors
epvector::const_iterator it = seq.begin(), itend = seq.end();
while (it != itend) {
if (!first) {
- c.s << '*';
+ if (is_of_type(c, print_latex))
+ c.s << ' ';
+ else
+ c.s << '*';
} else {
first = false;
}
- recombine_pair_to_ex(*it).print(c, precedence);
+ recombine_pair_to_ex(*it).print(c, precedence());
it++;
}
- if (precedence <= level)
- c.s << ")";
+ if (precedence() <= level) {
+ if (is_of_type(c, print_latex))
+ c.s << ")}";
+ else
+ c.s << ")";
+ }
}
}
return mul(s,overall_coeff.evalf(level));
}
+ex mul::evalm(void) const
+{
+ // numeric*matrix
+ if (seq.size() == 1 && seq[0].coeff.is_equal(_ex1())
+ && is_ex_of_type(seq[0].rest, matrix))
+ 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 = new epvector;
+ s->reserve(seq.size());
+
+ bool have_matrix = false;
+ epvector::iterator the_matrix;
+
+ epvector::const_iterator it = seq.begin(), itend = seq.end();
+ while (it != itend) {
+ const ex &m = recombine_pair_to_ex(*it).evalm();
+ s->push_back(split_ex_to_pair(m));
+ if (is_ex_of_type(m, matrix)) {
+ have_matrix = true;
+ the_matrix = s->end() - 1;
+ }
+ it++;
+ }
+
+ 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(s, overall_coeff))->setflag(status_flags::dynallocated);
+ return m.mul_scalar(scalar);
+
+ } else
+ return (new mul(s, overall_coeff))->setflag(status_flags::dynallocated);
+}
+
ex mul::simplify_ncmul(const exvector & v) const
{
- throw(std::logic_error("mul::simplify_ncmul() should never have been called!"));
+ if (seq.size()==0) {
+ return inherited::simplify_ncmul(v);
+ }
+
+ // Find first noncommutative element and call its simplify_ncmul()
+ for (epvector::const_iterator cit=seq.begin(); cit!=seq.end(); ++cit) {
+ if (cit->rest.return_type() == return_types::noncommutative)
+ return cit->rest.simplify_ncmul(v);
+ }
+ return inherited::simplify_ncmul(v);
}
// protected
return 0; // nothing has changed
}
-//////////
-// static member variables
-//////////
-
-// protected
-
-unsigned mul::precedence = 50;
-
} // namespace GiNaC