X-Git-Url: https://www.ginac.de/ginac.git//ginac.git?p=ginac.git;a=blobdiff_plain;f=ginac%2Fadd.cpp;h=b681a4f9f757be97195cbd34117118480540f887;hp=150b4f8222d0df346dd357b104656f9fd70aaf15;hb=c366645d84ba4cfdd5b98785a9c5e66e0aea3e62;hpb=9c91319253425e66f9b6feb9e7036f841bc55e84

diff --git a/ginac/add.cpp b/ginac/add.cpp
index 150b4f82..b681a4f9 100644
--- a/ginac/add.cpp
+++ b/ginac/add.cpp
@@ -25,6 +25,7 @@
 
 #include "add.h"
 #include "mul.h"
+#include "matrix.h"
 #include "archive.h"
 #include "debugmsg.h"
 #include "utils.h"
@@ -106,112 +107,124 @@ add::add(epvector * vp, const ex & oc)
 DEFAULT_ARCHIVING(add)
 
 //////////
-// functions overriding virtual functions from bases classes
+// functions overriding virtual functions from base classes
 //////////
 
 // public
 
-void add::print(std::ostream & os, unsigned upper_precedence) const
+void add::print(const print_context & c, unsigned level) const
 {
-	debugmsg("add print",LOGLEVEL_PRINT);
-	if (precedence<=upper_precedence) os << "(";
-	numeric coeff;
-	bool first = true;
-	// first print the overall numeric coefficient, if present:
-	if (!overall_coeff.is_zero()) {
-		os << overall_coeff;
-		first = false;
-	}
-	// then proceed with the remaining factors:
-	for (epvector::const_iterator cit=seq.begin(); cit!=seq.end(); ++cit) {
-		coeff = ex_to_numeric(cit->coeff);
-		if (!first) {
-			if (coeff.csgn()==-1) os << '-'; else os << '+';
-		} else {
-			if (coeff.csgn()==-1) os << '-';
+	debugmsg("add print", LOGLEVEL_PRINT);
+
+	if (is_a<print_tree>(c)) {
+
+		inherited::print(c, level);
+
+	} else if (is_a<print_csrc>(c)) {
+
+		if (precedence() <= level)
+			c.s << "(";
+	
+		// Print arguments, separated by "+"
+		epvector::const_iterator it = seq.begin(), itend = seq.end();
+		while (it != itend) {
+		
+			// If the coefficient is -1, it is replaced by a single minus sign
+			if (it->coeff.compare(_num1()) == 0) {
+				it->rest.bp->print(c, precedence());
+			} else if (it->coeff.compare(_num_1()) == 0) {
+				c.s << "-";
+				it->rest.bp->print(c, precedence());
+			} else if (ex_to<numeric>(it->coeff).numer().compare(_num1()) == 0) {
+				it->rest.bp->print(c, precedence());
+				c.s << "/";
+				ex_to<numeric>(it->coeff).denom().print(c, precedence());
+			} else if (ex_to<numeric>(it->coeff).numer().compare(_num_1()) == 0) {
+				c.s << "-";
+				it->rest.bp->print(c, precedence());
+				c.s << "/";
+				ex_to<numeric>(it->coeff).denom().print(c, precedence());
+			} else {
+				it->coeff.bp->print(c, precedence());
+				c.s << "*";
+				it->rest.bp->print(c, precedence());
+			}
+		
+			// Separator is "+", except if the following expression would have a leading minus sign
+			++it;
+			if (it != itend && !(it->coeff.compare(_num0()) < 0 || (it->coeff.compare(_num1()) == 0 && is_exactly_a<numeric>(it->rest) && it->rest.compare(_num0()) < 0)))
+				c.s << "+";
+		}
+	
+		if (!overall_coeff.is_zero()) {
+			if (overall_coeff.info(info_flags::positive))
+				c.s << '+';
+			overall_coeff.bp->print(c, precedence());
+		}
+	
+		if (precedence() <= level)
+			c.s << ")";
+
+	} else {
+
+		if (precedence() <= level) {
+			if (is_a<print_latex>(c))
+				c.s << "{(";
+			else
+				c.s << "(";
+		}
+
+		numeric coeff;
+		bool first = true;
+
+		// First print the overall numeric coefficient, if present
+		if (!overall_coeff.is_zero()) {
+			if (!is_a<print_tree>(c))
+				overall_coeff.print(c, 0);
+			else
+				overall_coeff.print(c, precedence());
 			first = false;
 		}
-		if (!coeff.is_equal(_num1()) &&
-		    !coeff.is_equal(_num_1())) {
-			if (coeff.is_rational()) {
-				if (coeff.is_negative())
-					os << -coeff;
-				else
-					os << coeff;
+
+		// Then proceed with the remaining factors
+		epvector::const_iterator it = seq.begin(), itend = seq.end();
+		while (it != itend) {
+			coeff = ex_to<numeric>(it->coeff);
+			if (!first) {
+				if (coeff.csgn() == -1) c.s << '-'; else c.s << '+';
 			} else {
-				if (coeff.csgn()==-1)
-					(-coeff).print(os, precedence);
+				if (coeff.csgn() == -1) c.s << '-';
+				first = false;
+			}
+			if (!coeff.is_equal(_num1()) &&
+			    !coeff.is_equal(_num_1())) {
+				if (coeff.is_rational()) {
+					if (coeff.is_negative())
+						(-coeff).print(c);
+					else
+						coeff.print(c);
+				} else {
+					if (coeff.csgn() == -1)
+						(-coeff).print(c, precedence());
+					else
+						coeff.print(c, precedence());
+				}
+				if (is_a<print_latex>(c))
+					c.s << ' ';
 				else
-					coeff.print(os, precedence);
+					c.s << '*';
 			}
-			os << '*';
+			it->rest.print(c, precedence());
+			++it;
 		}
-		cit->rest.print(os, precedence);
-	}
-	if (precedence<=upper_precedence) os << ")";
-}
-
-void add::printraw(std::ostream & os) const
-{
-	debugmsg("add printraw",LOGLEVEL_PRINT);
-
-	os << "+(";
-	for (epvector::const_iterator it=seq.begin(); it!=seq.end(); ++it) {
-		os << "(";
-		(*it).rest.bp->printraw(os);
-		os << ",";
-		(*it).coeff.bp->printraw(os);        
-		os << "),";
-	}
-	os << ",hash=" << hashvalue << ",flags=" << flags;
-	os << ")";
-}
 
-void add::printcsrc(std::ostream & os, unsigned type, unsigned upper_precedence) const
-{
-	debugmsg("add print csrc", LOGLEVEL_PRINT);
-	if (precedence <= upper_precedence)
-		os << "(";
-	
-	// Print arguments, separated by "+"
-	epvector::const_iterator it = seq.begin();
-	epvector::const_iterator itend = seq.end();
-	while (it != itend) {
-		
-		// If the coefficient is -1, it is replaced by a single minus sign
-		if (it->coeff.compare(_num1()) == 0) {
-			it->rest.bp->printcsrc(os, type, precedence);
-		} else if (it->coeff.compare(_num_1()) == 0) {
-			os << "-";
-			it->rest.bp->printcsrc(os, type, precedence);
-		} else if (ex_to_numeric(it->coeff).numer().compare(_num1()) == 0) {
-			it->rest.bp->printcsrc(os, type, precedence);
-			os << "/";
-			ex_to_numeric(it->coeff).denom().printcsrc(os, type, precedence);
-		} else if (ex_to_numeric(it->coeff).numer().compare(_num_1()) == 0) {
-			os << "-";
-			it->rest.bp->printcsrc(os, type, precedence);
-			os << "/";
-			ex_to_numeric(it->coeff).denom().printcsrc(os, type, precedence);
-		} else {
-			it->coeff.bp->printcsrc(os, type, precedence);
-			os << "*";
-			it->rest.bp->printcsrc(os, type, precedence);
+		if (precedence() <= level) {
+			if (is_a<print_latex>(c))
+				c.s << ")}";
+			else
+				c.s << ")";
 		}
-		
-		// Separator is "+", except if the following expression would have a leading minus sign
-		it++;
-		if (it != itend && !(it->coeff.compare(_num0()) < 0 || (it->coeff.compare(_num1()) == 0 && is_ex_exactly_of_type(it->rest, numeric) && it->rest.compare(_num0()) < 0)))
-			os << "+";
-	}
-	
-	if (!overall_coeff.is_zero()) {
-		if (overall_coeff.info(info_flags::positive)) os << '+';
-		overall_coeff.bp->printcsrc(os,type,precedence);
 	}
-	
-	if (precedence <= upper_precedence)
-		os << ")";
 }
 
 bool add::info(unsigned inf) const
@@ -223,16 +236,20 @@ bool add::info(unsigned inf) const
 		case info_flags::rational_polynomial:
 		case info_flags::crational_polynomial:
 		case info_flags::rational_function: {
-			for (epvector::const_iterator i=seq.begin(); i!=seq.end(); ++i) {
+			epvector::const_iterator i = seq.begin(), end = seq.end();
+			while (i != end) {
 				if (!(recombine_pair_to_ex(*i).info(inf)))
 					return false;
+				++i;
 			}
 			return overall_coeff.info(inf);
 		}
 		case info_flags::algebraic: {
-			for (epvector::const_iterator i=seq.begin(); i!=seq.end(); ++i) {
+			epvector::const_iterator i = seq.begin(), end = seq.end();
+			while (i != end) {
 				if ((recombine_pair_to_ex(*i).info(inf)))
 					return true;
+				++i;
 			}
 			return false;
 		}
@@ -240,50 +257,54 @@ bool add::info(unsigned inf) const
 	return inherited::info(inf);
 }
 
-int add::degree(const symbol & s) const
+int add::degree(const ex & s) const
 {
 	int deg = INT_MIN;
-	if (!overall_coeff.is_equal(_ex0()))
+	if (!overall_coeff.is_zero())
 		deg = 0;
 	
-	int cur_deg;
-	for (epvector::const_iterator cit=seq.begin(); cit!=seq.end(); ++cit) {
-		cur_deg = (*cit).rest.degree(s);
-		if (cur_deg>deg)
+	// Find maximum of degrees of individual terms
+	epvector::const_iterator i = seq.begin(), end = seq.end();
+	while (i != end) {
+		int cur_deg = i->rest.degree(s);
+		if (cur_deg > deg)
 			deg = cur_deg;
+		++i;
 	}
 	return deg;
 }
 
-int add::ldegree(const symbol & s) const
+int add::ldegree(const ex & s) const
 {
 	int deg = INT_MAX;
-	if (!overall_coeff.is_equal(_ex0()))
+	if (!overall_coeff.is_zero())
 		deg = 0;
 	
-	int cur_deg;
-	for (epvector::const_iterator cit=seq.begin(); cit!=seq.end(); ++cit) {
-		cur_deg = (*cit).rest.ldegree(s);
-		if (cur_deg<deg) deg=cur_deg;
+	// Find minimum of degrees of individual terms
+	epvector::const_iterator i = seq.begin(), end = seq.end();
+	while (i != end) {
+		int cur_deg = i->rest.ldegree(s);
+		if (cur_deg < deg)
+			deg = cur_deg;
+		++i;
 	}
 	return deg;
 }
 
-ex add::coeff(const symbol & s, int n) const
+ex add::coeff(const ex & s, int n) const
 {
-	epvector coeffseq;
-	coeffseq.reserve(seq.size());
-
-	epvector::const_iterator it=seq.begin();
-	while (it!=seq.end()) {
-		coeffseq.push_back(combine_ex_with_coeff_to_pair((*it).rest.coeff(s,n),
-		                                                 (*it).coeff));
-		++it;
+	epvector *coeffseq = new epvector();
+
+	// Calculate sum of coefficients in each term
+	epvector::const_iterator i = seq.begin(), end = seq.end();
+	while (i != end) {
+		ex restcoeff = i->rest.coeff(s, n);
+		if (!restcoeff.is_zero())
+			coeffseq->push_back(combine_ex_with_coeff_to_pair(restcoeff, i->coeff));
+		++i;
 	}
-	if (n==0) {
-		return (new add(coeffseq,overall_coeff))->setflag(status_flags::dynallocated);
-	}
-	return (new add(coeffseq))->setflag(status_flags::dynallocated);
+
+	return (new add(coeffseq, n==0 ? overall_coeff : _ex0()))->setflag(status_flags::dynallocated);
 }
 
 ex add::eval(int level) const
@@ -293,19 +314,21 @@ ex add::eval(int level) const
 	
 	debugmsg("add eval",LOGLEVEL_MEMBER_FUNCTION);
 	
-	epvector * evaled_seqp = evalchildren(level);
-	if (evaled_seqp!=0) {
+	epvector *evaled_seqp = evalchildren(level);
+	if (evaled_seqp) {
 		// do more evaluation later
-		return (new add(evaled_seqp,overall_coeff))->
+		return (new add(evaled_seqp, overall_coeff))->
 		       setflag(status_flags::dynallocated);
 	}
 	
 #ifdef DO_GINAC_ASSERT
-	for (epvector::const_iterator cit=seq.begin(); cit!=seq.end(); ++cit) {
-		GINAC_ASSERT(!is_ex_exactly_of_type((*cit).rest,add));
-		if (is_ex_exactly_of_type((*cit).rest,numeric))
+	epvector::const_iterator i = seq.begin(), end = seq.end();
+	while (i != end) {
+		GINAC_ASSERT(!is_ex_exactly_of_type(i->rest,add));
+		if (is_ex_exactly_of_type(i->rest,numeric))
 			dbgprint();
-		GINAC_ASSERT(!is_ex_exactly_of_type((*cit).rest,numeric));
+		GINAC_ASSERT(!is_ex_exactly_of_type(i->rest,numeric));
+		++i;
 	}
 #endif // def DO_GINAC_ASSERT
 	
@@ -316,32 +339,77 @@ ex add::eval(int level) const
 	}
 	
 	int seq_size = seq.size();
-	if (seq_size==0) {
+	if (seq_size == 0) {
 		// +(;c) -> c
 		return overall_coeff;
-	} else if ((seq_size==1) && overall_coeff.is_equal(_ex0())) {
+	} else if (seq_size == 1 && overall_coeff.is_zero()) {
 		// +(x;0) -> x
 		return recombine_pair_to_ex(*(seq.begin()));
+	} else if (!overall_coeff.is_zero() && seq[0].rest.return_type() != return_types::commutative) {
+		throw (std::logic_error("add::eval(): sum of non-commutative objects has non-zero numeric term"));
 	}
 	return this->hold();
 }
 
+ex add::evalm(void) const
+{
+	// Evaluate children first and add up all matrices. Stop if there's one
+	// term that is not a matrix.
+	epvector *s = new epvector;
+	s->reserve(seq.size());
+
+	bool all_matrices = true;
+	bool first_term = true;
+	matrix sum;
+
+	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)) {
+			if (first_term) {
+				sum = ex_to<matrix>(m);
+				first_term = false;
+			} else
+				sum = sum.add(ex_to<matrix>(m));
+		} else
+			all_matrices = false;
+		it++;
+	}
+
+	if (all_matrices) {
+		delete s;
+		return sum + overall_coeff;
+	} else
+		return (new add(s, overall_coeff))->setflag(status_flags::dynallocated);
+}
+
 ex add::simplify_ncmul(const exvector & v) const
 {
-	if (seq.size()==0) {
+	if (seq.empty())
 		return inherited::simplify_ncmul(v);
-	}
-	return (*seq.begin()).rest.simplify_ncmul(v);
+	else
+		return seq.begin()->rest.simplify_ncmul(v);
 }    
 
 // protected
 
 /** Implementation of ex::diff() for a sum. It differentiates each term.
  *  @see ex::diff */
-ex add::derivative(const symbol & s) const
+ex add::derivative(const symbol & y) const
 {
-	// D(a+b+c)=D(a)+D(b)+D(c)
-	return (new add(diffchildren(s)))->setflag(status_flags::dynallocated);
+	epvector *s = new epvector();
+	s->reserve(seq.size());
+	
+	// Only differentiate the "rest" parts of the expairs. This is faster
+	// than the default implementation in basic::derivative() although
+	// if performs the same function (differentiate each term).
+	epvector::const_iterator i = seq.begin(), end = seq.end();
+	while (i != end) {
+		s->push_back(combine_ex_with_coeff_to_pair(i->rest.diff(y), i->coeff));
+		++i;
+	}
+	return (new add(s, _ex0()))->setflag(status_flags::dynallocated);
 }
 
 int add::compare_same_type(const basic & other) const
@@ -356,18 +424,18 @@ bool add::is_equal_same_type(const basic & other) const
 
 unsigned add::return_type(void) const
 {
-	if (seq.size()==0) {
+	if (seq.empty())
 		return return_types::commutative;
-	}
-	return (*seq.begin()).rest.return_type();
+	else
+		return seq.begin()->rest.return_type();
 }
    
 unsigned add::return_type_tinfo(void) const
 {
-	if (seq.size()==0) {
+	if (seq.empty())
 		return tinfo_key;
-	}
-	return (*seq.begin()).rest.return_type_tinfo();
+	else
+		return seq.begin()->rest.return_type_tinfo();
 }
 
 ex add::thisexpairseq(const epvector & v, const ex & oc) const
@@ -383,7 +451,7 @@ ex add::thisexpairseq(epvector * vp, const ex & oc) const
 expair add::split_ex_to_pair(const ex & e) const
 {
 	if (is_ex_exactly_of_type(e,mul)) {
-		const mul &mulref = ex_to_mul(e);
+		const mul &mulref(ex_to<mul>(e));
 		ex numfactor = mulref.overall_coeff;
 		mul *mulcopyp = new mul(mulref);
 		mulcopyp->overall_coeff = _ex1();
@@ -400,7 +468,7 @@ expair add::combine_ex_with_coeff_to_pair(const ex & e,
 {
 	GINAC_ASSERT(is_ex_exactly_of_type(c, numeric));
 	if (is_ex_exactly_of_type(e, mul)) {
-		const mul &mulref = ex_to_mul(e);
+		const mul &mulref(ex_to<mul>(e));
 		ex numfactor = mulref.overall_coeff;
 		mul *mulcopyp = new mul(mulref);
 		mulcopyp->overall_coeff = _ex1();
@@ -412,11 +480,11 @@ expair add::combine_ex_with_coeff_to_pair(const ex & e,
 		else if (are_ex_trivially_equal(numfactor, _ex1()))
 			return expair(*mulcopyp, c);
 		else
-			return expair(*mulcopyp, ex_to_numeric(numfactor).mul_dyn(ex_to_numeric(c)));
+			return expair(*mulcopyp, ex_to<numeric>(numfactor).mul_dyn(ex_to<numeric>(c)));
 	} else if (is_ex_exactly_of_type(e, numeric)) {
 		if (are_ex_trivially_equal(c, _ex1()))
 			return expair(e, _ex1());
-		return expair(ex_to_numeric(e).mul_dyn(ex_to_numeric(c)), _ex1());
+		return expair(ex_to<numeric>(e).mul_dyn(ex_to<numeric>(c)), _ex1());
 	}
 	return expair(e, c);
 }
@@ -428,16 +496,16 @@ expair add::combine_pair_with_coeff_to_pair(const expair & p,
 	GINAC_ASSERT(is_ex_exactly_of_type(c,numeric));
 
 	if (is_ex_exactly_of_type(p.rest,numeric)) {
-		GINAC_ASSERT(ex_to_numeric(p.coeff).is_equal(_num1())); // should be normalized
-		return expair(ex_to_numeric(p.rest).mul_dyn(ex_to_numeric(c)),_ex1());
+		GINAC_ASSERT(ex_to<numeric>(p.coeff).is_equal(_num1())); // should be normalized
+		return expair(ex_to<numeric>(p.rest).mul_dyn(ex_to<numeric>(c)),_ex1());
 	}
 
-	return expair(p.rest,ex_to_numeric(p.coeff).mul_dyn(ex_to_numeric(c)));
+	return expair(p.rest,ex_to<numeric>(p.coeff).mul_dyn(ex_to<numeric>(c)));
 }
 	
 ex add::recombine_pair_to_ex(const expair & p) const
 {
-	if (ex_to_numeric(p.coeff).is_equal(_num1()))
+	if (ex_to<numeric>(p.coeff).is_equal(_num1()))
 		return p.rest;
 	else
 		return p.rest*p.coeff;
@@ -445,25 +513,13 @@ ex add::recombine_pair_to_ex(const expair & p) const
 
 ex add::expand(unsigned options) const
 {
-	if (flags & status_flags::expanded)
-		return *this;
-	
-	epvector * vp = expandchildren(options);
-	if (vp==0) {
+	epvector *vp = expandchildren(options);
+	if (vp == NULL) {
 		// the terms have not changed, so it is safe to declare this expanded
-		setflag(status_flags::expanded);
-		return *this;
+		return (options == 0) ? setflag(status_flags::expanded) : *this;
 	}
 	
-	return (new add(vp,overall_coeff))->setflag(status_flags::expanded | status_flags::dynallocated);
+	return (new add(vp, overall_coeff))->setflag(status_flags::dynallocated | (options == 0 ? status_flags::expanded : 0));
 }
 
-//////////
-// static member variables
-//////////
-
-// protected
-
-unsigned add::precedence = 40;
-
 } // namespace GiNaC