* Fix CLN output of a-2. (Chris Dams)

[ginac.git] / ginac / add.cpp

diff --git a/ginac/add.cpp b/ginac/add.cpp
index 1f71b0606d7ff9b9ed9f9c943e075412a7e945d4..f3721e66f042ccec5e28936ee85ad56c8b8598a0 100644 (file)
--- a/ginac/add.cpp
+++ b/ginac/add.cpp
@@ -3,7 +3,7 @@
  *  Implementation of GiNaC's sums of expressions. */
 
 /*
- *  GiNaC Copyright (C) 1999-2001 Johannes Gutenberg University Mainz, Germany
+ *  GiNaC Copyright (C) 1999-2002 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
@@ -25,8 +25,9 @@
 
 #include "add.h"
 #include "mul.h"
-#include "matrix.h"
 #include "archive.h"
+#include "operators.h"
+#include "matrix.h"
 #include "utils.h"
 
 namespace GiNaC {
@@ -121,16 +122,16 @@ void add::print(const print_context & c, unsigned level) const
                while (it != itend) {
                
                        // If the coefficient is -1, it is replaced by a single minus sign
-                       if (it->coeff.compare(_num1) == 0) {
+                       if (it->coeff.is_equal(_ex1)) {
                                it->rest.print(c, precedence());
-                       } else if (it->coeff.compare(_num_1) == 0) {
+                       } else if (it->coeff.is_equal(_ex_1)) {
                                c.s << "-";
                                it->rest.print(c, precedence());
-                       } else if (ex_to<numeric>(it->coeff).numer().compare(_num1) == 0) {
+                       } 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().compare(_num_1) == 0) {
+                       } else if (ex_to<numeric>(it->coeff).numer().is_equal(_num_1)) {
                                c.s << "-";
                                it->rest.print(c, precedence());
                                c.s << "/";
@@ -141,21 +142,34 @@ void add::print(const print_context & c, unsigned level) const
                                it->rest.print(c, precedence());
                        }
                
-                       // Separator is "+", except if the following expression would have a leading minus sign
+                       // 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 && !(it->coeff.compare(_num0) < 0 || (it->coeff.compare(_num1) == 0 && is_exactly_a<numeric>(it->rest) && it->rest.compare(_num0) < 0)))
+                       if (it != itend
+                        && (is_a<print_csrc_cl_N>(c)  // 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))
+                       if (overall_coeff.info(info_flags::positive)
+                        || is_a<print_csrc_cl_N>(c))  // sign inside ctor argument
                                c.s << '+';
                        overall_coeff.print(c, precedence());
                }
-       
+               
                if (precedence() <= level)
                        c.s << ")";
 
+       } else if (is_a<print_python_repr>(c)) {
+
+               c.s << class_name() << '(';
+               op(0).print(c);
+               for (unsigned i=1; i<nops(); ++i) {
+                       c.s << ',';
+                       op(i).print(c);
+               }
+               c.s << ')';
+
        } else {
 
                if (precedence() <= level) {
@@ -318,7 +332,7 @@ ex add::eval(int level) const
        epvector::const_iterator i = seq.begin(), end = seq.end();
        while (i != end) {
                GINAC_ASSERT(!is_exactly_a<add>(i->rest));
-               if (is_ex_exactly_of_type(i->rest,numeric))
+               if (is_exactly_a<numeric>(i->rest))
                        dbgprint();
                GINAC_ASSERT(!is_exactly_a<numeric>(i->rest));
                ++i;
@@ -359,7 +373,7 @@ ex add::evalm(void) const
        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 (is_a<matrix>(m)) {
                        if (first_term) {
                                sum = ex_to<matrix>(m);
                                first_term = false;
@@ -410,11 +424,6 @@ int add::compare_same_type(const basic & other) const
        return inherited::compare_same_type(other);
 }
 
-bool add::is_equal_same_type(const basic & other) const
-{
-       return inherited::is_equal_same_type(other);
-}
-
 unsigned add::return_type(void) const
 {
        if (seq.empty())
@@ -443,9 +452,9 @@ 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)) {
+       if (is_exactly_a<mul>(e)) {
                const mul &mulref(ex_to<mul>(e));
-               ex numfactor = mulref.overall_coeff;
+               const ex &numfactor = mulref.overall_coeff;
                mul *mulcopyp = new mul(mulref);
                mulcopyp->overall_coeff = _ex1;
                mulcopyp->clearflag(status_flags::evaluated);
@@ -460,22 +469,22 @@ expair add::combine_ex_with_coeff_to_pair(const ex & e,
                                                                                  const ex & c) const
 {
        GINAC_ASSERT(is_exactly_a<numeric>(c));
-       if (is_ex_exactly_of_type(e, mul)) {
+       if (is_exactly_a<mul>(e)) {
                const mul &mulref(ex_to<mul>(e));
-               ex numfactor = mulref.overall_coeff;
+               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 (are_ex_trivially_equal(c, _ex1))
+               if (c.is_equal(_ex1))
                        return expair(*mulcopyp, numfactor);
-               else if (are_ex_trivially_equal(numfactor, _ex1))
+               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_ex_exactly_of_type(e, numeric)) {
-               if (are_ex_trivially_equal(c, _ex1))
+       } 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);
        }
@@ -488,7 +497,7 @@ expair add::combine_pair_with_coeff_to_pair(const expair & p,
        GINAC_ASSERT(is_exactly_a<numeric>(p.coeff));
        GINAC_ASSERT(is_exactly_a<numeric>(c));
 
-       if (is_ex_exactly_of_type(p.rest,numeric)) {
+       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);
        }
@@ -501,7 +510,7 @@ ex add::recombine_pair_to_ex(const expair & p) const
        if (ex_to<numeric>(p.coeff).is_equal(_num1))
                return p.rest;
        else
-               return p.rest*p.coeff;
+               return (new mul(p.rest,p.coeff))->setflag(status_flags::dynallocated);
 }
 
 ex add::expand(unsigned options) const