X-Git-Url: https://www.ginac.de/ginac.git//ginac.git?p=ginac.git;a=blobdiff_plain;f=ginac%2Fadd.cpp;h=cb6c8031ec21f7d3f18826f3974c3ba226255f4d;hp=42e65bb904ea7171fe42007dfc61d0471dbca5eb;hb=d54e497297f4687c385ff8fbc91296365887c7c0;hpb=a8507b8af1c08d9b27d98d57f95c7ca1a8671e27

diff --git a/ginac/add.cpp b/ginac/add.cpp
index 42e65bb9..cb6c8031 100644
--- a/ginac/add.cpp
+++ b/ginac/add.cpp
@@ -1,8 +1,9 @@
 /** @file add.cpp
  *
- *  Implementation of GiNaC's sums of expressions.
- *
- *  GiNaC Copyright (C) 1999 Johannes Gutenberg University Mainz, Germany
+ *  Implementation of GiNaC's sums of expressions. */
+
+/*
+ *  GiNaC Copyright (C) 1999-2003 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
@@ -22,52 +23,29 @@
 #include <iostream>
 #include <stdexcept>
 
-#include "ginac.h"
+#include "add.h"
+#include "mul.h"
+#include "archive.h"
+#include "operators.h"
+#include "matrix.h"
+#include "utils.h"
+
+namespace GiNaC {
+
+GINAC_IMPLEMENT_REGISTERED_CLASS_OPT(add, expairseq,
+  print_func<print_context>(&add::do_print).
+  print_func<print_latex>(&add::do_print_latex).
+  print_func<print_csrc>(&add::do_print_csrc).
+  print_func<print_tree>(&inherited::do_print_tree).
+  print_func<print_python_repr>(&add::do_print_python_repr))
 
 //////////
-// default constructor, destructor, copy constructor assignment operator and helpers
+// default constructor
 //////////
 
-// public
-
 add::add()
 {
-    debugmsg("add default constructor",LOGLEVEL_CONSTRUCT);
-    tinfo_key = TINFO_ADD;
-}
-
-add::~add()
-{
-    debugmsg("add destructor",LOGLEVEL_DESTRUCT);
-    destroy(0);
-}
-
-add::add(add const & other)
-{
-    debugmsg("add copy constructor",LOGLEVEL_CONSTRUCT);
-    copy(other);
-}
-
-add const & add::operator=(add const & other)
-{
-    debugmsg("add operator=",LOGLEVEL_ASSIGNMENT);
-    if (this != &other) {
-        destroy(1);
-        copy(other);
-    }
-    return *this;
-}
-
-// protected
-
-void add::copy(add const & other)
-{
-    expairseq::copy(other);
-}
-
-void add::destroy(bool call_parent)
-{
-    if (call_parent) expairseq::destroy(call_parent);
+	tinfo_key = TINFO_add;
 }
 
 //////////
@@ -76,577 +54,465 @@ void add::destroy(bool call_parent)
 
 // public
 
-add::add(ex const & lh, ex const & rh)
+add::add(const ex & lh, const ex & rh)
 {
-    debugmsg("add constructor from ex,ex",LOGLEVEL_CONSTRUCT);
-    tinfo_key = TINFO_ADD;
-    overall_coeff=exZERO();
-    construct_from_2_ex(lh,rh);
-    ASSERT(is_canonical());
+	tinfo_key = TINFO_add;
+	overall_coeff = _ex0;
+	construct_from_2_ex(lh,rh);
+	GINAC_ASSERT(is_canonical());
 }
 
-add::add(exvector const & v)
+add::add(const exvector & v)
 {
-    debugmsg("add constructor from exvector",LOGLEVEL_CONSTRUCT);
-    tinfo_key = TINFO_ADD;
-    overall_coeff=exZERO();
-    construct_from_exvector(v);
-    ASSERT(is_canonical());
+	tinfo_key = TINFO_add;
+	overall_coeff = _ex0;
+	construct_from_exvector(v);
+	GINAC_ASSERT(is_canonical());
 }
 
-/*
-add::add(epvector const & v, bool do_not_canonicalize)
+add::add(const epvector & v)
 {
-    debugmsg("add constructor from epvector,bool",LOGLEVEL_CONSTRUCT);
-    tinfo_key = TINFO_ADD;
-    if (do_not_canonicalize) {
-        seq=v;
-#ifdef EXPAIRSEQ_USE_HASHTAB
-        combine_same_terms(); // to build hashtab
-#endif // def EXPAIRSEQ_USE_HASHTAB
-    } else {
-        construct_from_epvector(v);
-    }
-    ASSERT(is_canonical());
+	tinfo_key = TINFO_add;
+	overall_coeff = _ex0;
+	construct_from_epvector(v);
+	GINAC_ASSERT(is_canonical());
 }
-*/
 
-add::add(epvector const & v)
+add::add(const epvector & v, const ex & oc)
 {
-    debugmsg("add constructor from epvector",LOGLEVEL_CONSTRUCT);
-    tinfo_key = TINFO_ADD;
-    overall_coeff=exZERO();
-    construct_from_epvector(v);
-    ASSERT(is_canonical());
+	tinfo_key = TINFO_add;
+	overall_coeff = oc;
+	construct_from_epvector(v);
+	GINAC_ASSERT(is_canonical());
 }
 
-add::add(epvector const & v, ex const & oc)
+add::add(std::auto_ptr<epvector> vp, const ex & oc)
 {
-    debugmsg("add constructor from epvector,ex",LOGLEVEL_CONSTRUCT);
-    tinfo_key = TINFO_ADD;
-    overall_coeff=oc;
-    construct_from_epvector(v);
-    ASSERT(is_canonical());
+	tinfo_key = TINFO_add;
+	GINAC_ASSERT(vp!=0);
+	overall_coeff = oc;
+	construct_from_epvector(*vp);
+	GINAC_ASSERT(is_canonical());
 }
 
-add::add(epvector * vp, ex const & oc)
-{
-    debugmsg("add constructor from epvector *,ex",LOGLEVEL_CONSTRUCT);
-    tinfo_key = TINFO_ADD;
-    ASSERT(vp!=0);
-    overall_coeff=oc;
-    construct_from_epvector(*vp);
-    delete vp;
-    ASSERT(is_canonical());
-}
+//////////
+// archiving
+//////////
+
+DEFAULT_ARCHIVING(add)
 
 //////////
-// functions overriding virtual functions from bases classes
+// functions overriding virtual functions from base classes
 //////////
 
 // public
 
-basic * add::duplicate() const
-{
-    debugmsg("add duplicate",LOGLEVEL_DUPLICATE);
-    return new add(*this);
+void add::print_add(const print_context & c, const char *openbrace, const char *closebrace, const char *mul_sym, unsigned level) const
+{
+	if (precedence() <= level)
+		c.s << openbrace << '(';
+
+	numeric coeff;
+	bool first = true;
+
+	// First print the overall numeric coefficient, if present
+	if (!overall_coeff.is_zero()) {
+		overall_coeff.print(c, 0);
+		first = false;
+	}
+
+	// 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) 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());
+			}
+			c.s << mul_sym;
+		}
+		it->rest.print(c, precedence());
+		++it;
+	}
+
+	if (precedence() <= level)
+		c.s << ')' << closebrace;
+}
+
+void add::do_print(const print_context & c, unsigned level) const
+{
+	print_add(c, "", "", "*", level);
+}
+
+void add::do_print_latex(const print_latex & c, unsigned level) const
+{
+	print_add(c, "{", "}", " ", level);
+}
+
+void add::do_print_csrc(const print_csrc & c, unsigned level) const
+{
+	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.is_equal(_ex1)) {
+			it->rest.print(c, precedence());
+		} else if (it->coeff.is_equal(_ex_1)) {
+			c.s << "-";
+			it->rest.print(c, precedence());
+		} else if (ex_to<numeric>(it->coeff).numer().is_equal(_num1)) {
+			it->rest.print(c, precedence());
+			c.s << "/";
+			ex_to<numeric>(it->coeff).denom().print(c, precedence());
+		} else if (ex_to<numeric>(it->coeff).numer().is_equal(_num_1)) {
+			c.s << "-";
+			it->rest.print(c, precedence());
+			c.s << "/";
+			ex_to<numeric>(it->coeff).denom().print(c, precedence());
+		} else {
+			it->coeff.print(c, precedence());
+			c.s << "*";
+			it->rest.print(c, precedence());
+		}
+		
+		// Separator is "+", except if the following expression would have a leading minus sign or the sign is sitting in parenthesis (as in a ctor)
+		++it;
+		if (it != itend
+		 && (is_a<print_csrc_cl_N>(c) || !it->coeff.info(info_flags::real)  // sign inside ctor arguments
+		  || !(it->coeff.info(info_flags::negative) || (it->coeff.is_equal(_num1) && is_exactly_a<numeric>(it->rest) && it->rest.info(info_flags::negative)))))
+			c.s << "+";
+	}
+	
+	if (!overall_coeff.is_zero()) {
+		if (overall_coeff.info(info_flags::positive)
+		 || is_a<print_csrc_cl_N>(c) || !overall_coeff.info(info_flags::real))  // sign inside ctor argument
+			c.s << '+';
+		overall_coeff.print(c, precedence());
+	}
+		
+	if (precedence() <= level)
+		c.s << ")";
+}
+
+void add::do_print_python_repr(const print_python_repr & c, unsigned level) const
+{
+	c.s << class_name() << '(';
+	op(0).print(c);
+	for (size_t i=1; i<nops(); ++i) {
+		c.s << ',';
+		op(i).print(c);
+	}
+	c.s << ')';
 }
 
 bool add::info(unsigned inf) const
 {
-    // TODO: optimize
-    if (inf==info_flags::polynomial || inf==info_flags::integer_polynomial || inf==info_flags::rational_polynomial || inf==info_flags::rational_function) {
-        for (epvector::const_iterator it=seq.begin(); it!=seq.end(); ++it) {
-            if (!(recombine_pair_to_ex(*it).info(inf)))
-                return false;
-        }
-        return true;
-    } else {
-        return expairseq::info(inf);
-    }
-}
-
-int add::degree(symbol const & s) const
-{
-    int deg=INT_MIN;
-    if (!overall_coeff.is_equal(exZERO())) {
-        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) deg=cur_deg;
-    }
-    return deg;
-}
-
-int add::ldegree(symbol const & s) const
-{
-    int deg=INT_MAX;
-    if (!overall_coeff.is_equal(exZERO())) {
-        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;
-    }
-    return deg;
-}
-
-ex add::coeff(symbol const & s, int const 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;
-    }
-    if (n==0) {
-        return (new add(coeffseq,overall_coeff))->setflag(status_flags::dynallocated);
-    }
-    return (new add(coeffseq))->setflag(status_flags::dynallocated);
-}
-
-/*
-ex add::eval(int level) const
-{
-    // simplifications: +(...,x,c1,c2) -> +(...,x,c1+c2) (c1, c2 numeric())
-    //                  +(...,(c1,c2)) -> (...,(c1*c2,1)) (normalize)
-    //                  +(...,x,0) -> +(...,x)
-    //                  +(x) -> x
-    //                  +() -> 0
-
-    debugmsg("add eval",LOGLEVEL_MEMBER_FUNCTION);
-
-    epvector newseq=seq;
-    epvector::iterator it1,it2;
-    
-    // +(...,x,c1,c2) -> +(...,x,c1+c2) (c1, c2 numeric())
-    it2=newseq.end()-1;
-    it1=it2-1;
-    while ((newseq.size()>=2)&&is_exactly_of_type(*(*it1).rest.bp,numeric)&&
-                               is_exactly_of_type(*(*it2).rest.bp,numeric)) {
-        *it1=expair(ex_to_numeric((*it1).rest).mul(ex_to_numeric((*it1).coeff))
-                    .add(ex_to_numeric((*it2).rest).mul(ex_to_numeric((*it2).coeff))),exONE());
-        newseq.pop_back();
-        it2=newseq.end()-1;
-        it1=it2-1;
-    }
-
-    if ((newseq.size()>=1)&&is_exactly_of_type(*(*it2).rest.bp,numeric)) {
-        // +(...,(c1,c2)) -> (...,(c1*c2,1)) (normalize)
-        *it2=expair(ex_to_numeric((*it2).rest).mul(ex_to_numeric((*it2).coeff)),exONE());
-        // +(...,x,0) -> +(...,x)
-        if (ex_to_numeric((*it2).rest).compare(0)==0) {
-            newseq.pop_back();
-        }
-    }
-
-    if (newseq.size()==0) {
-        // +() -> 0
-        return exZERO();
-    } else if (newseq.size()==1) {
-        // +(x) -> x
-        return recombine_pair_to_ex(*(newseq.begin()));
-    }
-
-    return (new add(newseq,1))->setflag(status_flags::dynallocated  |
-                                        status_flags::evaluated );
-}
-*/
-
-/*
-ex add::eval(int level) const
-{
-    // simplifications: +(...,x,c1,c2) -> +(...,x,c1+c2) (c1, c2 numeric())
-    //                  +(...,(c1,c2)) -> (...,(c1*c2,1)) (normalize)
-    //                  +(...,x,0) -> +(...,x)
-    //                  +(x) -> x
-    //                  +() -> 0
-
-    debugmsg("add eval",LOGLEVEL_MEMBER_FUNCTION);
-
-    if ((level==1)&&(flags & status_flags::evaluated)) {
-#ifdef DOASSERT
-        for (epvector::const_iterator cit=seq.begin(); cit!=seq.end(); ++cit) {
-            ASSERT(!is_ex_exactly_of_type((*cit).rest,add));
-            ASSERT(!(is_ex_exactly_of_type((*cit).rest,numeric)&&
-                     (ex_to_numeric((*cit).coeff).compare(numONE())!=0)));
-        }
-#endif // def DOASSERT
-        return *this;
-    }
-
-    epvector newseq;
-    epvector::iterator it1,it2;
-    bool seq_copied=false;
-
-    epvector * evaled_seqp=evalchildren(level);
-    if (evaled_seqp!=0) {
-        // do more evaluation later
-        return (new add(evaled_seqp))->setflag(status_flags::dynallocated);
-    }
-
-#ifdef DOASSERT
-    for (epvector::const_iterator cit=seq.begin(); cit!=seq.end(); ++cit) {
-        ASSERT(!is_ex_exactly_of_type((*cit).rest,add));
-        ASSERT(!(is_ex_exactly_of_type((*cit).rest,numeric)&&
-                 (ex_to_numeric((*cit).coeff).compare(numONE())!=0)));
-    }
-#endif // def DOASSERT
-
-    if (flags & status_flags::evaluated) {
-        return *this;
-    }
-    
-    expair const & last_expair=*(seq.end()-1);
-    expair const & next_to_last_expair=*(seq.end()-2);
-    int seq_size = seq.size();
-
-    // +(...,x,c1,c2) -> +(...,x,c1+c2) (c1, c2 numeric())
-    if ((!seq_copied)&&(seq_size>=2)&&
-        is_ex_exactly_of_type(last_expair.rest,numeric)&&
-        is_ex_exactly_of_type(next_to_last_expair.rest,numeric)) {
-        newseq=seq;
-        seq_copied=true;
-        it2=newseq.end()-1;
-        it1=it2-1;
-    }
-    while (seq_copied&&(newseq.size()>=2)&&
-           is_ex_exactly_of_type((*it1).rest,numeric)&&
-           is_ex_exactly_of_type((*it2).rest,numeric)) {
-        *it1=expair(ex_to_numeric((*it1).rest).mul(ex_to_numeric((*it1).coeff))
-                    .add_dyn(ex_to_numeric((*it2).rest).mul(ex_to_numeric((*it2).coeff))),exONE());
-        newseq.pop_back();
-        it2=newseq.end()-1;
-        it1=it2-1;
-    }
-
-    // +(...,(c1,c2)) -> (...,(c1*c2,1)) (normalize)
-    if ((!seq_copied)&&(seq_size>=1)&&
-        (is_ex_exactly_of_type(last_expair.rest,numeric))&&
-        (ex_to_numeric(last_expair.coeff).compare(numONE())!=0)) {
-        newseq=seq;
-        seq_copied=true;
-        it2=newseq.end()-1;
-    }
-    if (seq_copied&&(newseq.size()>=1)&&
-        (is_ex_exactly_of_type((*it2).rest,numeric))&&
-        (ex_to_numeric((*it2).coeff).compare(numONE())!=0)) {
-        *it2=expair(ex_to_numeric((*it2).rest).mul_dyn(ex_to_numeric((*it2).coeff)),exONE());
-    }
-        
-    // +(...,x,0) -> +(...,x)
-    if ((!seq_copied)&&(seq_size>=1)&&
-        (is_ex_exactly_of_type(last_expair.rest,numeric))&&
-        (ex_to_numeric(last_expair.rest).is_zero())) {
-        newseq=seq;
-        seq_copied=true;
-        it2=newseq.end()-1;
-    }
-    if (seq_copied&&(newseq.size()>=1)&&
-        (is_ex_exactly_of_type((*it2).rest,numeric))&&
-        (ex_to_numeric((*it2).rest).is_zero())) {
-        newseq.pop_back();
-    }
-
-    // +() -> 0
-    if ((!seq_copied)&&(seq_size==0)) {
-        return exZERO();
-    } else if (seq_copied&&(newseq.size()==0)) {
-        return exZERO();
-    }
-
-    // +(x) -> x
-    if ((!seq_copied)&&(seq_size==1)) {
-        return recombine_pair_to_ex(*(seq.begin()));
-    } else if (seq_copied&&(newseq.size()==1)) {
-        return recombine_pair_to_ex(*(newseq.begin()));
-    }
-
-    if (!seq_copied) return this->hold();
-
-    return (new add(newseq,1))->setflag(status_flags::dynallocated  |
-                                        status_flags::evaluated );
-}
-*/
-
+	switch (inf) {
+		case info_flags::polynomial:
+		case info_flags::integer_polynomial:
+		case info_flags::cinteger_polynomial:
+		case info_flags::rational_polynomial:
+		case info_flags::crational_polynomial:
+		case info_flags::rational_function: {
+			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: {
+			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;
+		}
+	}
+	return inherited::info(inf);
+}
+
+int add::degree(const ex & s) const
+{
+	int deg = INT_MIN;
+	if (!overall_coeff.is_zero())
+		deg = 0;
+	
+	// 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 ex & s) const
+{
+	int deg = INT_MAX;
+	if (!overall_coeff.is_zero())
+		deg = 0;
+	
+	// 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 ex & s, int n) const
+{
+	std::auto_ptr<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;
+	}
+
+	return (new add(coeffseq, n==0 ? overall_coeff : _ex0))->setflag(status_flags::dynallocated);
+}
+
+/** Perform automatic term rewriting rules in this class.  In the following
+ *  x stands for a symbolic variables of type ex and c stands for such
+ *  an expression that contain a plain number.
+ *  - +(;c) -> c
+ *  - +(x;0) -> x
+ *
+ *  @param level cut-off in recursive evaluation */
 ex add::eval(int level) const
 {
-    // simplifications: +(;c) -> c
-    //                  +(x;1) -> x
-
-    debugmsg("add eval",LOGLEVEL_MEMBER_FUNCTION);
-
-    epvector * evaled_seqp=evalchildren(level);
-    if (evaled_seqp!=0) {
-        // do more evaluation later
-        return (new add(evaled_seqp,overall_coeff))->
-                   setflag(status_flags::dynallocated);
-    }
-
-#ifdef DOASSERT
-    for (epvector::const_iterator cit=seq.begin(); cit!=seq.end(); ++cit) {
-        ASSERT(!is_ex_exactly_of_type((*cit).rest,add));
-        if (is_ex_exactly_of_type((*cit).rest,numeric)) {
-            dbgprint();
-        }
-        ASSERT(!is_ex_exactly_of_type((*cit).rest,numeric));
-    }
-#endif // def DOASSERT
-
-    if (flags & status_flags::evaluated) {
-        ASSERT(seq.size()>0);
-        ASSERT((seq.size()>1)||!overall_coeff.is_equal(exZERO()));
-        return *this;
-    }
-
-    int seq_size=seq.size();
-    if (seq_size==0) {
-        // +(;c) -> c
-        return overall_coeff;
-    } else if ((seq_size==1)&&overall_coeff.is_equal(exZERO())) {
-        // +(x;0) -> x
-        return recombine_pair_to_ex(*(seq.begin()));
-    }
-    return this->hold();
-}
-
-exvector add::get_indices(void) const
-{
-    // all terms in the sum should have the same indices (compatible tensors)
-    // however this is not checked, since there is no function yet which
-    // compares indices (idxvector can be unsorted) !!!!!!!!!!!
-    if (seq.size()==0) {
-        return exvector();
-    }
-    return (seq.begin())->rest.get_indices();
-}    
-
-ex add::simplify_ncmul(exvector const & v) const
-{
-    if (seq.size()==0) {
-        return expairseq::simplify_ncmul(v);
-    }
-    return (*seq.begin()).rest.simplify_ncmul(v);
+	std::auto_ptr<epvector> evaled_seqp = evalchildren(level);
+	if (evaled_seqp.get()) {
+		// do more evaluation later
+		return (new add(evaled_seqp, overall_coeff))->
+		       setflag(status_flags::dynallocated);
+	}
+	
+#ifdef DO_GINAC_ASSERT
+	epvector::const_iterator i = seq.begin(), end = seq.end();
+	while (i != end) {
+		GINAC_ASSERT(!is_exactly_a<add>(i->rest));
+		if (is_exactly_a<numeric>(i->rest))
+			dbgprint();
+		GINAC_ASSERT(!is_exactly_a<numeric>(i->rest));
+		++i;
+	}
+#endif // def DO_GINAC_ASSERT
+	
+	if (flags & status_flags::evaluated) {
+		GINAC_ASSERT(seq.size()>0);
+		GINAC_ASSERT(seq.size()>1 || !overall_coeff.is_zero());
+		return *this;
+	}
+	
+	int seq_size = seq.size();
+	if (seq_size == 0) {
+		// +(;c) -> c
+		return overall_coeff;
+	} 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() const
+{
+	// Evaluate children first and add up all matrices. Stop if there's one
+	// term that is not a matrix.
+	std::auto_ptr<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_a<matrix>(m)) {
+			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)
+		return sum + overall_coeff;
+	else
+		return (new add(s, overall_coeff))->setflag(status_flags::dynallocated);
+}
+
+ex add::eval_ncmul(const exvector & v) const
+{
+	if (seq.empty())
+		return inherited::eval_ncmul(v);
+	else
+		return seq.begin()->rest.eval_ncmul(v);
 }    
 
 // protected
 
-int add::compare_same_type(basic const & other) const
+/** Implementation of ex::diff() for a sum. It differentiates each term.
+ *  @see ex::diff */
+ex add::derivative(const symbol & y) const
 {
-    return expairseq::compare_same_type(other);
+	std::auto_ptr<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);
 }
 
-bool add::is_equal_same_type(basic const & other) const
+int add::compare_same_type(const basic & other) const
 {
-    return expairseq::is_equal_same_type(other);
+	return inherited::compare_same_type(other);
 }
 
-unsigned add::return_type(void) const
+unsigned add::return_type() const
 {
-    if (seq.size()==0) {
-        return return_types::commutative;
-    }
-    return (*seq.begin()).rest.return_type();
+	if (seq.empty())
+		return return_types::commutative;
+	else
+		return seq.begin()->rest.return_type();
 }
    
-unsigned add::return_type_tinfo(void) const
+unsigned add::return_type_tinfo() const
 {
-    if (seq.size()==0) {
-        return tinfo_key;
-    }
-    return (*seq.begin()).rest.return_type_tinfo();
+	if (seq.empty())
+		return tinfo_key;
+	else
+		return seq.begin()->rest.return_type_tinfo();
 }
 
-ex add::thisexpairseq(epvector const & v, ex const & oc) const
+ex add::thisexpairseq(const epvector & v, const ex & oc) const
 {
-    return (new add(v,oc))->setflag(status_flags::dynallocated);
+	return (new add(v,oc))->setflag(status_flags::dynallocated);
 }
 
-ex add::thisexpairseq(epvector * vp, ex const & oc) const
+ex add::thisexpairseq(std::auto_ptr<epvector> vp, const ex & oc) const
 {
-    return (new add(vp,oc))->setflag(status_flags::dynallocated);
+	return (new add(vp,oc))->setflag(status_flags::dynallocated);
 }
 
-/*
-expair add::split_ex_to_pair(ex const & e) const
+expair add::split_ex_to_pair(const ex & e) const
 {
-    if (is_ex_exactly_of_type(e,mul)) {
-        mul const & mulref=ex_to_mul(e);
-        ASSERT(mulref.seq.size()>1);
-        ex const & lastfactor_rest=(*(mulref.seq.end()-1)).rest;
-        ex const & lastfactor_coeff=(*(mulref.seq.end()-1)).coeff;
-        if (is_ex_exactly_of_type(lastfactor_rest,numeric) &&
-            ex_to_numeric(lastfactor_coeff).is_equal(numONE())) {
-            epvector s=mulref.seq;
-            //s.pop_back();
-            //return expair((new mul(s,1))->setflag(status_flags::dynallocated),
-            //              lastfactor);
-            mul * mulp=static_cast<mul *>(mulref.duplicate());
-#ifdef EXPAIRSEQ_USE_HASHTAB
-            mulp->remove_hashtab_entry(mulp->seq.end()-1);
-#endif // def EXPAIRSEQ_USE_HASHTAB
-            mulp->seq.pop_back();
-#ifdef EXPAIRSEQ_USE_HASHTAB
-            mulp->shrink_hashtab();
-#endif // def EXPAIRSEQ_USE_HASHTAB
-            mulp->clearflag(status_flags::evaluated);
-            mulp->clearflag(status_flags::hash_calculated);
-            return expair(mulp->setflag(status_flags::dynallocated),lastfactor_rest);
-        }
-    }
-    return expair(e,exONE());
+	if (is_exactly_a<mul>(e)) {
+		const mul &mulref(ex_to<mul>(e));
+		const ex &numfactor = mulref.overall_coeff;
+		mul *mulcopyp = new mul(mulref);
+		mulcopyp->overall_coeff = _ex1;
+		mulcopyp->clearflag(status_flags::evaluated);
+		mulcopyp->clearflag(status_flags::hash_calculated);
+		mulcopyp->setflag(status_flags::dynallocated);
+		return expair(*mulcopyp,numfactor);
+	}
+	return expair(e,_ex1);
 }
-*/
 
-expair add::split_ex_to_pair(ex const & e) const
+expair add::combine_ex_with_coeff_to_pair(const ex & e,
+										  const ex & c) const
 {
-    if (is_ex_exactly_of_type(e,mul)) {
-        mul const & mulref=ex_to_mul(e);
-        ex numfactor=mulref.overall_coeff;
-        // mul * mulcopyp=static_cast<mul *>(mulref.duplicate());
-        mul * mulcopyp=new mul(mulref);
-        mulcopyp->overall_coeff=exONE();
-        mulcopyp->clearflag(status_flags::evaluated);
-        mulcopyp->clearflag(status_flags::hash_calculated);
-        return expair(mulcopyp->setflag(status_flags::dynallocated),numfactor);
-    }
-    return expair(e,exONE());
+	GINAC_ASSERT(is_exactly_a<numeric>(c));
+	if (is_exactly_a<mul>(e)) {
+		const mul &mulref(ex_to<mul>(e));
+		const ex &numfactor = mulref.overall_coeff;
+		mul *mulcopyp = new mul(mulref);
+		mulcopyp->overall_coeff = _ex1;
+		mulcopyp->clearflag(status_flags::evaluated);
+		mulcopyp->clearflag(status_flags::hash_calculated);
+		mulcopyp->setflag(status_flags::dynallocated);
+		if (c.is_equal(_ex1))
+			return expair(*mulcopyp, numfactor);
+		else if (numfactor.is_equal(_ex1))
+			return expair(*mulcopyp, c);
+		else
+			return expair(*mulcopyp, ex_to<numeric>(numfactor).mul_dyn(ex_to<numeric>(c)));
+	} else if (is_exactly_a<numeric>(e)) {
+		if (c.is_equal(_ex1))
+			return expair(e, _ex1);
+		return expair(ex_to<numeric>(e).mul_dyn(ex_to<numeric>(c)), _ex1);
+	}
+	return expair(e, c);
 }
 
-/*
-expair add::combine_ex_with_coeff_to_pair(ex const & e,
-                                          ex const & c) const
-{
-    ASSERT(is_ex_exactly_of_type(c,numeric));
-    if (is_ex_exactly_of_type(e,mul)) {
-        mul const & mulref=ex_to_mul(e);
-        ASSERT(mulref.seq.size()>1);
-        ex const & lastfactor_rest=(*(mulref.seq.end()-1)).rest;
-        ex const & lastfactor_coeff=(*(mulref.seq.end()-1)).coeff;
-        if (is_ex_exactly_of_type(lastfactor_rest,numeric) &&
-            ex_to_numeric(lastfactor_coeff).is_equal(numONE())) {
-            //epvector s=mulref.seq;
-            //s.pop_back();
-            //return expair((new mul(s,1))->setflag(status_flags::dynallocated),
-            //              ex_to_numeric(lastfactor).mul_dyn(ex_to_numeric(c)));
-            mul * mulp=static_cast<mul *>(mulref.duplicate());
-#ifdef EXPAIRSEQ_USE_HASHTAB
-            mulp->remove_hashtab_entry(mulp->seq.end()-1);
-#endif // def EXPAIRSEQ_USE_HASHTAB
-            mulp->seq.pop_back();
-#ifdef EXPAIRSEQ_USE_HASHTAB
-            mulp->shrink_hashtab();
-#endif // def EXPAIRSEQ_USE_HASHTAB
-            mulp->clearflag(status_flags::evaluated);
-            mulp->clearflag(status_flags::hash_calculated);
-            if (are_ex_trivially_equal(c,exONE())) {
-                return expair(mulp->setflag(status_flags::dynallocated),lastfactor_rest);
-            } else if (are_ex_trivially_equal(lastfactor_rest,exONE())) {
-                return expair(mulp->setflag(status_flags::dynallocated),c);
-            }                
-            return expair(mulp->setflag(status_flags::dynallocated),
-                          ex_to_numeric(lastfactor_rest).mul_dyn(ex_to_numeric(c)));
-        }
-    }
-    return expair(e,c);
-}
-*/
-
-expair add::combine_ex_with_coeff_to_pair(ex const & e,
-                                          ex const & c) const
-{
-    ASSERT(is_ex_exactly_of_type(c,numeric));
-    if (is_ex_exactly_of_type(e,mul)) {
-        mul const & mulref=ex_to_mul(e);
-        ex numfactor=mulref.overall_coeff;
-        //mul * mulcopyp=static_cast<mul *>(mulref.duplicate());
-        mul * mulcopyp=new mul(mulref);
-        mulcopyp->overall_coeff=exONE();
-        mulcopyp->clearflag(status_flags::evaluated);
-        mulcopyp->clearflag(status_flags::hash_calculated);
-        if (are_ex_trivially_equal(c,exONE())) {
-            return expair(mulcopyp->setflag(status_flags::dynallocated),numfactor);
-        } else if (are_ex_trivially_equal(numfactor,exONE())) {
-            return expair(mulcopyp->setflag(status_flags::dynallocated),c);
-        }
-        return expair(mulcopyp->setflag(status_flags::dynallocated),
-                          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,exONE())) {
-            return expair(e,exONE());
-        }
-        return expair(ex_to_numeric(e).mul_dyn(ex_to_numeric(c)),exONE());
-    }
-    return expair(e,c);
-}
-    
-expair add::combine_pair_with_coeff_to_pair(expair const & p,
-                                            ex const & c) const
+expair add::combine_pair_with_coeff_to_pair(const expair & p,
+											const ex & c) const
 {
-    ASSERT(is_ex_exactly_of_type(p.coeff,numeric));
-    ASSERT(is_ex_exactly_of_type(c,numeric));
+	GINAC_ASSERT(is_exactly_a<numeric>(p.coeff));
+	GINAC_ASSERT(is_exactly_a<numeric>(c));
 
-    if (is_ex_exactly_of_type(p.rest,numeric)) {
-        ASSERT(ex_to_numeric(p.coeff).is_equal(numONE())); // should be normalized
-        return expair(ex_to_numeric(p.rest).mul_dyn(ex_to_numeric(c)),exONE());
-    }
+	if (is_exactly_a<numeric>(p.rest)) {
+		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(expair const & p) const
+	
+ex add::recombine_pair_to_ex(const expair & p) const
 {
-    //if (p.coeff.compare(exONE())==0) {
-    //if (are_ex_trivially_equal(p.coeff,exONE())) {
-    if (ex_to_numeric(p.coeff).is_equal(numONE())) {
-        return p.rest;
-    } else {
-        return p.rest*p.coeff;
-    }
+	if (ex_to<numeric>(p.coeff).is_equal(_num1))
+		return p.rest;
+	else
+		return (new mul(p.rest,p.coeff))->setflag(status_flags::dynallocated);
 }
 
 ex add::expand(unsigned options) const
 {
-    epvector * vp=expandchildren(options);
-    if (vp==0) {
-        return *this;
-    }
-    return (new add(vp,overall_coeff))->setflag(status_flags::expanded    |
-                                                status_flags::dynallocated );
-}
-
-//////////
-// new virtual functions which can be overridden by derived classes
-//////////
-
-// none
-
-//////////
-// non-virtual functions in this class
-//////////
-
-// none
-
-//////////
-// static member variables
-//////////
-
-// protected
-
-unsigned add::precedence=40;
-
-//////////
-// global constants
-//////////
-
-const add some_add;
-type_info const & typeid_add=typeid(some_add);
-
+	std::auto_ptr<epvector> vp = expandchildren(options);
+	if (vp.get() == 0) {
+		// the terms have not changed, so it is safe to declare this expanded
+		return (options == 0) ? setflag(status_flags::expanded) : *this;
+	}
 
+	return (new add(vp, overall_coeff))->setflag(status_flags::dynallocated | (options == 0 ? status_flags::expanded : 0));
+}
 
+} // namespace GiNaC