X-Git-Url: https://www.ginac.de/ginac.git//ginac.git?p=ginac.git;a=blobdiff_plain;f=ginac%2Fadd.cpp;h=069e3e02865dfe362d8fd05b7b491e442a372717;hp=804f07ae8ddebc12aaf83be08a8e4c8018fd415e;hb=dbb36db8d02b2c25af6bbfff8135112637936e1f;hpb=26741891dadf23162799009b6fd57b4984bd4ce5

diff --git a/ginac/add.cpp b/ginac/add.cpp
index 804f07ae..069e3e02 100644
--- a/ginac/add.cpp
+++ b/ginac/add.cpp
@@ -3,7 +3,7 @@
  *  Implementation of GiNaC's sums of expressions. */
 
 /*
- *  GiNaC Copyright (C) 1999 Johannes Gutenberg University Mainz, Germany
+ *  GiNaC Copyright (C) 1999-2000 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,12 +25,16 @@
 
 #include "add.h"
 #include "mul.h"
+#include "archive.h"
 #include "debugmsg.h"
+#include "utils.h"
 
 #ifndef NO_GINAC_NAMESPACE
 namespace GiNaC {
 #endif // ndef NO_GINAC_NAMESPACE
 
+GINAC_IMPLEMENT_REGISTERED_CLASS(add, expairseq)
+
 //////////
 // default constructor, destructor, copy constructor assignment operator and helpers
 //////////
@@ -49,13 +53,13 @@ add::~add()
     destroy(0);
 }
 
-add::add(add const & other)
+add::add(const add & other)
 {
     debugmsg("add copy constructor",LOGLEVEL_CONSTRUCT);
     copy(other);
 }
 
-add const & add::operator=(add const & other)
+const add & add::operator=(const add & other)
 {
     debugmsg("add operator=",LOGLEVEL_ASSIGNMENT);
     if (this != &other) {
@@ -67,14 +71,14 @@ add const & add::operator=(add const & other)
 
 // protected
 
-void add::copy(add const & other)
+void add::copy(const add & other)
 {
-    expairseq::copy(other);
+    inherited::copy(other);
 }
 
 void add::destroy(bool call_parent)
 {
-    if (call_parent) expairseq::destroy(call_parent);
+    if (call_parent) inherited::destroy(call_parent);
 }
 
 //////////
@@ -83,26 +87,26 @@ 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();
+    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();
+    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, bool do_not_canonicalize)
 {
     debugmsg("add constructor from epvector,bool",LOGLEVEL_CONSTRUCT);
     tinfo_key = TINFO_add;
@@ -118,16 +122,16 @@ add::add(epvector const & v, bool do_not_canonicalize)
 }
 */
 
-add::add(epvector const & v)
+add::add(const epvector & v)
 {
     debugmsg("add constructor from epvector",LOGLEVEL_CONSTRUCT);
     tinfo_key = TINFO_add;
-    overall_coeff=exZERO();
+    overall_coeff=_ex0();
     construct_from_epvector(v);
     GINAC_ASSERT(is_canonical());
 }
 
-add::add(epvector const & v, ex const & oc)
+add::add(const epvector & v, const ex & oc)
 {
     debugmsg("add constructor from epvector,ex",LOGLEVEL_CONSTRUCT);
     tinfo_key = TINFO_add;
@@ -136,7 +140,7 @@ add::add(epvector const & v, ex const & oc)
     GINAC_ASSERT(is_canonical());
 }
 
-add::add(epvector * vp, ex const & oc)
+add::add(epvector * vp, const ex & oc)
 {
     debugmsg("add constructor from epvector *,ex",LOGLEVEL_CONSTRUCT);
     tinfo_key = TINFO_add;
@@ -147,6 +151,28 @@ add::add(epvector * vp, ex const & oc)
     GINAC_ASSERT(is_canonical());
 }
 
+//////////
+// archiving
+//////////
+
+/** Construct object from archive_node. */
+add::add(const archive_node &n, const lst &sym_lst) : inherited(n, sym_lst)
+{
+    debugmsg("add constructor from archive_node", LOGLEVEL_CONSTRUCT);
+}
+
+/** Unarchive the object. */
+ex add::unarchive(const archive_node &n, const lst &sym_lst)
+{
+    return (new add(n, sym_lst))->setflag(status_flags::dynallocated);
+}
+
+/** Archive the object. */
+void add::archive(archive_node &n) const
+{
+    inherited::archive(n);
+}
+
 //////////
 // functions overriding virtual functions from bases classes
 //////////
@@ -164,30 +190,38 @@ void add::print(ostream & os, unsigned upper_precedence) const
     debugmsg("add print",LOGLEVEL_PRINT);
     if (precedence<=upper_precedence) os << "(";
     numeric coeff;
-    bool first=true;
+    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 << '-';
-            first=false;
+            first = false;
         }
-        if (!coeff.is_equal(numONE()) &&
-            !coeff.is_equal(numMINUSONE())) {
-            if (coeff.csgn()==-1)
-                (numMINUSONE()*coeff).print(os, precedence);
-            else
-                coeff.print(os, precedence);
+        if (!coeff.is_equal(_num1()) &&
+            !coeff.is_equal(_num_1())) {
+            if (coeff.is_rational()) {
+                if (coeff.is_negative())
+                    os << -coeff;
+                else
+                    os << coeff;
+            } else {
+                if (coeff.csgn()==-1)
+                    (-coeff).print(os, precedence);
+                else
+                    coeff.print(os, precedence);
+            }
             os << '*';
         }
         os << cit->rest;
     }
-    // print the overall numeric coefficient, if present:
-    if (!overall_coeff.is_zero()) {
-        if (overall_coeff.info(info_flags::positive)) os << '+';
-        os << overall_coeff;
-    }
     if (precedence<=upper_precedence) os << ")";
 }
 
@@ -219,16 +253,16 @@ void add::printcsrc(ostream & os, unsigned type, unsigned upper_precedence) cons
     while (it != itend) {
 
         // If the coefficient is -1, it is replaced by a single minus sign
-        if (it->coeff.compare(numONE()) == 0) {
+        if (it->coeff.compare(_num1()) == 0) {
             it->rest.bp->printcsrc(os, type, precedence);
-        } else if (it->coeff.compare(numMINUSONE()) == 0) {
+        } 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(numONE()) == 0) {
+        } 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(numMINUSONE()) == 0) {
+        } else if (ex_to_numeric(it->coeff).numer().compare(_num_1()) == 0) {
             os << "-";
             it->rest.bp->printcsrc(os, type, precedence);
             os << "/";
@@ -241,11 +275,11 @@ void add::printcsrc(ostream & os, unsigned type, unsigned upper_precedence) cons
 
         // Separator is "+", except if the following expression would have a leading minus sign
         it++;
-        if (it != itend && !(it->coeff.compare(numZERO()) < 0 || (it->coeff.compare(numONE()) == 0 && is_ex_exactly_of_type(it->rest, numeric) && it->rest.compare(numZERO()) < 0)))
+        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_equal(exZERO())) {
+    if (!overall_coeff.is_equal(_ex0())) {
         if (overall_coeff.info(info_flags::positive)) os << '+';
         overall_coeff.bp->printcsrc(os,type,precedence);
     }
@@ -269,14 +303,14 @@ bool add::info(unsigned inf) const
         }
         return overall_coeff.info(inf);
     } else {
-        return expairseq::info(inf);
+        return inherited::info(inf);
     }
 }
 
-int add::degree(symbol const & s) const
+int add::degree(const symbol & s) const
 {
     int deg=INT_MIN;
-    if (!overall_coeff.is_equal(exZERO())) {
+    if (!overall_coeff.is_equal(_ex0())) {
         deg=0;
     }
     int cur_deg;
@@ -287,10 +321,10 @@ int add::degree(symbol const & s) const
     return deg;
 }
 
-int add::ldegree(symbol const & s) const
+int add::ldegree(const symbol & s) const
 {
     int deg=INT_MAX;
-    if (!overall_coeff.is_equal(exZERO())) {
+    if (!overall_coeff.is_equal(_ex0())) {
         deg=0;
     }
     int cur_deg;
@@ -301,7 +335,7 @@ int add::ldegree(symbol const & s) const
     return deg;
 }
 
-ex add::coeff(symbol const & s, int const n) const
+ex add::coeff(const symbol & s, int n) const
 {
     epvector coeffseq;
     coeffseq.reserve(seq.size());
@@ -344,7 +378,7 @@ ex add::eval(int level) const
 
     if (flags & status_flags::evaluated) {
         GINAC_ASSERT(seq.size()>0);
-        GINAC_ASSERT((seq.size()>1)||!overall_coeff.is_equal(exZERO()));
+        GINAC_ASSERT((seq.size()>1)||!overall_coeff.is_equal(_ex0()));
         return *this;
     }
 
@@ -352,7 +386,7 @@ ex add::eval(int level) const
     if (seq_size==0) {
         // +(;c) -> c
         return overall_coeff;
-    } else if ((seq_size==1)&&overall_coeff.is_equal(exZERO())) {
+    } else if ((seq_size==1)&&overall_coeff.is_equal(_ex0())) {
         // +(x;0) -> x
         return recombine_pair_to_ex(*(seq.begin()));
     }
@@ -370,24 +404,24 @@ exvector add::get_indices(void) const
     return (seq.begin())->rest.get_indices();
 }    
 
-ex add::simplify_ncmul(exvector const & v) const
+ex add::simplify_ncmul(const exvector & v) const
 {
     if (seq.size()==0) {
-        return expairseq::simplify_ncmul(v);
+        return inherited::simplify_ncmul(v);
     }
     return (*seq.begin()).rest.simplify_ncmul(v);
 }    
 
 // protected
 
-int add::compare_same_type(basic const & other) const
+int add::compare_same_type(const basic & other) const
 {
-    return expairseq::compare_same_type(other);
+    return inherited::compare_same_type(other);
 }
 
-bool add::is_equal_same_type(basic const & other) const
+bool add::is_equal_same_type(const basic & other) const
 {
-    return expairseq::is_equal_same_type(other);
+    return inherited::is_equal_same_type(other);
 }
 
 unsigned add::return_type(void) const
@@ -406,78 +440,78 @@ unsigned add::return_type_tinfo(void) const
     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);
 }
 
-ex add::thisexpairseq(epvector * vp, ex const & oc) const
+ex add::thisexpairseq(epvector * vp, const ex & oc) const
 {
     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);
+        const mul & 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->overall_coeff=_ex1();
         mulcopyp->clearflag(status_flags::evaluated);
         mulcopyp->clearflag(status_flags::hash_calculated);
         return expair(mulcopyp->setflag(status_flags::dynallocated),numfactor);
     }
-    return expair(e,exONE());
+    return expair(e,_ex1());
 }
 
-expair add::combine_ex_with_coeff_to_pair(ex const & e,
-                                          ex const & c) const
+expair add::combine_ex_with_coeff_to_pair(const ex & e,
+                                          const ex & c) const
 {
     GINAC_ASSERT(is_ex_exactly_of_type(c,numeric));
     if (is_ex_exactly_of_type(e,mul)) {
-        mul const & mulref=ex_to_mul(e);
+        const mul & 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->overall_coeff=_ex1();
         mulcopyp->clearflag(status_flags::evaluated);
         mulcopyp->clearflag(status_flags::hash_calculated);
-        if (are_ex_trivially_equal(c,exONE())) {
+        if (are_ex_trivially_equal(c,_ex1())) {
             return expair(mulcopyp->setflag(status_flags::dynallocated),numfactor);
-        } else if (are_ex_trivially_equal(numfactor,exONE())) {
+        } else if (are_ex_trivially_equal(numfactor,_ex1())) {
             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());
+        if (are_ex_trivially_equal(c,_ex1())) {
+            return expair(e,_ex1());
         }
-        return expair(ex_to_numeric(e).mul_dyn(ex_to_numeric(c)),exONE());
+        return expair(ex_to_numeric(e).mul_dyn(ex_to_numeric(c)),_ex1());
     }
     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
 {
     GINAC_ASSERT(is_ex_exactly_of_type(p.coeff,numeric));
     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(numONE())); // should be normalized
-        return expair(ex_to_numeric(p.rest).mul_dyn(ex_to_numeric(c)),exONE());
+        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)));
 }
     
-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())) {
+    //if (p.coeff.compare(_ex1())==0) {
+    //if (are_ex_trivially_equal(p.coeff,_ex1())) {
+    if (ex_to_numeric(p.coeff).is_equal(_num1())) {
         return p.rest;
     } else {
         return p.rest*p.coeff;
@@ -519,7 +553,7 @@ unsigned add::precedence=40;
 //////////
 
 const add some_add;
-type_info const & typeid_add=typeid(some_add);
+const type_info & typeid_add=typeid(some_add);
 
 #ifndef NO_GINAC_NAMESPACE
 } // namespace GiNaC