introduced new class for constructing symmetry tree definitions

[ginac.git] / ginac / add.cpp

diff --git a/ginac/add.cpp b/ginac/add.cpp
index 802c23721d0c04beda4533527d6d819615eeb6b0..17faae2c60244e76a2cdfd8f998d1294facf68fa 100644 (file)
--- 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"
@@ -121,7 +122,7 @@ void add::print(const print_context & c, unsigned level) const
 
        } else if (is_of_type(c, print_csrc)) {
 
-               if (precedence <= level)
+               if (precedence() <= level)
                        c.s << "(";
        
                // Print arguments, separated by "+"
@@ -130,23 +131,23 @@ void add::print(const print_context & c, unsigned level) const
                
                        // 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);
+                               it->rest.bp->print(c, precedence());
                        } else if (it->coeff.compare(_num_1()) == 0) {
                                c.s << "-";
-                               it->rest.bp->print(c, precedence);
+                               it->rest.bp->print(c, precedence());
                        } else if (ex_to_numeric(it->coeff).numer().compare(_num1()) == 0) {
-                               it->rest.bp->print(c, precedence);
+                               it->rest.bp->print(c, precedence());
                                c.s << "/";
-                               ex_to_numeric(it->coeff).denom().print(c, precedence);
+                               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);
+                               it->rest.bp->print(c, precedence());
                                c.s << "/";
-                               ex_to_numeric(it->coeff).denom().print(c, precedence);
+                               ex_to_numeric(it->coeff).denom().print(c, precedence());
                        } else {
-                               it->coeff.bp->print(c, precedence);
+                               it->coeff.bp->print(c, precedence());
                                c.s << "*";
-                               it->rest.bp->print(c, precedence);
+                               it->rest.bp->print(c, precedence());
                        }
                
                        // Separator is "+", except if the following expression would have a leading minus sign
@@ -158,16 +159,20 @@ void add::print(const print_context & c, unsigned level) const
                if (!overall_coeff.is_zero()) {
                        if (overall_coeff.info(info_flags::positive))
                                c.s << '+';
-                       overall_coeff.bp->print(c, precedence);
+                       overall_coeff.bp->print(c, precedence());
                }
        
-               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 << "(";
+               }
 
                numeric coeff;
                bool first = true;
@@ -177,7 +182,7 @@ void add::print(const print_context & c, unsigned level) const
                        if (!is_of_type(c, print_tree))
                                overall_coeff.print(c, 0);
                        else
-                               overall_coeff.print(c, precedence);
+                               overall_coeff.print(c, precedence());
                        first = false;
                }
 
@@ -200,18 +205,25 @@ void add::print(const print_context & c, unsigned level) const
                                                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 << '*';
                        }
-                       it->rest.print(c, precedence);
+                       it->rest.print(c, precedence());
                        it++;
                }
 
-               if (precedence <= level)
-                       c.s << ")";
+               if (precedence() <= level) {
+                       if (is_of_type(c, print_latex))
+                               c.s << ")}";
+                       else
+                               c.s << ")";
+               }
        }
 }
 
@@ -273,18 +285,16 @@ int add::ldegree(const ex & s) 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));
+               ex restcoeff = it->rest.coeff(s,n);
+               if (!restcoeff.is_zero())
+                       coeffseq.push_back(combine_ex_with_coeff_to_pair(restcoeff,it->coeff));
                ++it;
        }
-       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 : default_overall_coeff()))->setflag(status_flags::dynallocated);
 }
 
 ex add::eval(int level) const
@@ -327,6 +337,38 @@ ex add::eval(int level) const
        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)
+               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) {
@@ -459,12 +501,4 @@ ex add::expand(unsigned options) const
        return (new add(vp,overall_coeff))->setflag(status_flags::expanded | status_flags::dynallocated);
 }
 
-//////////
-// static member variables
-//////////
-
-// protected
-
-unsigned add::precedence = 40;
-
 } // namespace GiNaC