X-Git-Url: https://www.ginac.de/ginac.git//ginac.git?p=ginac.git;a=blobdiff_plain;f=ginac%2Fex.cpp;h=a390d71475f58d4dc71cc26783ca547ef18563a0;hp=147cd97ffd6144a3edf9abaea61081f6f31d16f2;hb=d52c15ce1c91dc1063dadfc5f56fa9d9def1205d;hpb=487e5659efe401683eee0381b0d23f967ffffc3c

diff --git a/ginac/ex.cpp b/ginac/ex.cpp
index 147cd97f..a390d714 100644
--- a/ginac/ex.cpp
+++ b/ginac/ex.cpp
@@ -3,7 +3,7 @@
  *  Implementation of GiNaC's light-weight expression handles. */
 
 /*
- *  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
@@ -28,6 +28,12 @@
 #include "ncmul.h"
 #include "numeric.h"
 #include "power.h"
+#include "debugmsg.h"
+#include "utils.h"
+
+#ifndef NO_NAMESPACE_GINAC
+namespace GiNaC {
+#endif // ndef NO_NAMESPACE_GINAC
 
 //////////
 // default constructor, destructor, copy constructor assignment operator and helpers
@@ -37,40 +43,40 @@
 
 #ifndef INLINE_EX_CONSTRUCTORS
 
-ex::ex() : bp(exZERO().bp)
+ex::ex() : bp(ex0().bp)
 {
     debugmsg("ex default constructor",LOGLEVEL_CONSTRUCT);
-    ASSERT(exZERO().bp!=0);
-    ASSERT(exZERO().bp->flags & status_flags::dynallocated);
-    ASSERT(bp!=0);
+    GINAC_ASSERT(ex0().bp!=0);
+    GINAC_ASSERT(ex0().bp->flags & status_flags::dynallocated);
+    GINAC_ASSERT(bp!=0);
     ++bp->refcount;
 }
 
 ex::~ex()
 {
     debugmsg("ex destructor",LOGLEVEL_DESTRUCT);
-    ASSERT(bp!=0);
-    ASSERT(bp->flags & status_flags::dynallocated);
+    GINAC_ASSERT(bp!=0);
+    GINAC_ASSERT(bp->flags & status_flags::dynallocated);
     if (--bp->refcount == 0) {
         delete bp;
     }
 }
 
-ex::ex(ex const & other) : bp(other.bp)
+ex::ex(const ex & other) : bp(other.bp)
 {
     debugmsg("ex copy constructor",LOGLEVEL_CONSTRUCT);
-    ASSERT(bp!=0);
-    ASSERT((bp->flags) & status_flags::dynallocated);
+    GINAC_ASSERT(bp!=0);
+    GINAC_ASSERT((bp->flags) & status_flags::dynallocated);
     ++bp->refcount;
 }
 
-ex const & ex::operator=(ex const & other)
+const ex & ex::operator=(const ex & other)
 {
     debugmsg("ex operator=",LOGLEVEL_ASSIGNMENT);
-    ASSERT(bp!=0);
-    ASSERT(bp->flags & status_flags::dynallocated);
-    ASSERT(other.bp!=0);
-    ASSERT(other.bp->flags & status_flags::dynallocated);
+    GINAC_ASSERT(bp!=0);
+    GINAC_ASSERT(bp->flags & status_flags::dynallocated);
+    GINAC_ASSERT(other.bp!=0);
+    GINAC_ASSERT(other.bp->flags & status_flags::dynallocated);
     ++other.bp->refcount;
     basic * tmpbp=other.bp;
     if (--bp->refcount==0) {
@@ -89,43 +95,45 @@ ex const & ex::operator=(ex const & other)
 // public
 
 #ifndef INLINE_EX_CONSTRUCTORS
-ex::ex(basic const & other)
+
+ex::ex(const basic & other)
 {
     debugmsg("ex constructor from basic",LOGLEVEL_CONSTRUCT);
     construct_from_basic(other);
 }
-#endif
 
-ex::ex(int const i)
+ex::ex(int i)
 {
     debugmsg("ex constructor from int",LOGLEVEL_CONSTRUCT);
-    construct_from_basic(numeric(i));
+    construct_from_int(i);
 }
 
-ex::ex(unsigned int const i)
+ex::ex(unsigned int i)
 {
     debugmsg("ex constructor from unsigned int",LOGLEVEL_CONSTRUCT);
-    construct_from_basic(numeric(i));
+    construct_from_uint(i);
 }
 
-ex::ex(long const i)
+ex::ex(long i)
 {
     debugmsg("ex constructor from long",LOGLEVEL_CONSTRUCT);
-    construct_from_basic(numeric(i));
+    construct_from_long(i);
 }
 
-ex::ex(unsigned long const i)
+ex::ex(unsigned long i)
 {
     debugmsg("ex constructor from unsigned long",LOGLEVEL_CONSTRUCT);
-    construct_from_basic(numeric(i));
+    construct_from_ulong(i);
 }
 
 ex::ex(double const d)
 {
     debugmsg("ex constructor from double",LOGLEVEL_CONSTRUCT);
-    construct_from_basic(numeric(d));
+    construct_from_double(d);
 }
-    
+
+#endif // ndef INLINE_EX_CONSTRUCTORS
+
 //////////
 // functions overriding virtual functions from bases classes
 //////////
@@ -144,20 +152,89 @@ ex::ex(double const d)
 
 // public
 
+/** Swap the contents of two expressions. */
 void ex::swap(ex & other)
 {
     debugmsg("ex swap",LOGLEVEL_MEMBER_FUNCTION);
 
-    ASSERT(bp!=0);
-    ASSERT(bp->flags & status_flags::dynallocated);
-    ASSERT(other.bp!=0);
-    ASSERT(other.bp->flags & status_flags::dynallocated);
+    GINAC_ASSERT(bp!=0);
+    GINAC_ASSERT(bp->flags & status_flags::dynallocated);
+    GINAC_ASSERT(other.bp!=0);
+    GINAC_ASSERT(other.bp->flags & status_flags::dynallocated);
     
     basic * tmpbp=bp;
     bp=other.bp;
     other.bp=tmpbp;
 }
 
+/** Output formatted to be useful as ginsh input. */
+void ex::print(ostream & os, unsigned upper_precedence) const
+{
+    debugmsg("ex print",LOGLEVEL_PRINT);
+    GINAC_ASSERT(bp!=0);
+    bp->print(os,upper_precedence);
+}
+
+void ex::printraw(ostream & os) const
+{
+    debugmsg("ex printraw",LOGLEVEL_PRINT);
+    GINAC_ASSERT(bp!=0);
+    os << "ex(";
+    bp->printraw(os);
+    os << ")";
+}
+
+void ex::printtree(ostream & os, unsigned indent) const
+{
+    debugmsg("ex printtree",LOGLEVEL_PRINT);
+    GINAC_ASSERT(bp!=0);
+    // os << "refcount=" << bp->refcount << " ";
+    bp->printtree(os,indent);
+}
+
+/** Print expression as a C++ statement. The output looks like
+ *  "<type> <var_name> = <expression>;". The "type" parameter has an effect
+ *  on how number literals are printed.
+ *
+ *  @param os output stream
+ *  @param type variable type (one of the csrc_types)
+ *  @param var_name variable name to be printed */
+void ex::printcsrc(ostream & os, unsigned type, const char *var_name) const
+{
+    debugmsg("ex print csrc", LOGLEVEL_PRINT);
+    GINAC_ASSERT(bp!=0);
+    switch (type) {
+        case csrc_types::ctype_float:
+            os << "float ";
+            break;
+        case csrc_types::ctype_double:
+            os << "double ";
+            break;
+        case csrc_types::ctype_cl_N:
+            os << "cl_N ";
+            break;
+    }
+    os << var_name << " = ";
+    bp->printcsrc(os, type, 0);
+    os << ";\n";
+}
+
+/** Little wrapper arount print to be called within a debugger. */
+void ex::dbgprint(void) const
+{
+    debugmsg("ex dbgprint",LOGLEVEL_PRINT);
+    GINAC_ASSERT(bp!=0);
+    bp->dbgprint();
+}
+
+/** Little wrapper arount printtree to be called within a debugger. */
+void ex::dbgprinttree(void) const
+{
+    debugmsg("ex dbgprinttree",LOGLEVEL_PRINT);
+    GINAC_ASSERT(bp!=0);
+    bp->dbgprinttree();
+}
+
 bool ex::info(unsigned inf) const
 {
     if (inf == info_flags::normal_form) {
@@ -173,7 +250,7 @@ bool ex::info(unsigned inf) const
     // polynomial^(int) * polynomial^(int) * ... is in normal form
     if (!is_ex_exactly_of_type(*this, mul))
         return false;
-    for (int i=0; i<nops(); i++) {
+    for (unsigned i=0; i<nops(); i++) {
         if (is_ex_exactly_of_type(op(i), power)) {
             if (!op(i).op(1).info(info_flags::integer))
                 return false;
@@ -189,39 +266,39 @@ bool ex::info(unsigned inf) const
     }
 }
 
-int ex::nops() const
+unsigned ex::nops() const
 {
-    ASSERT(bp!=0);
+    GINAC_ASSERT(bp!=0);
     return bp->nops();
 }
 
 ex ex::expand(unsigned options) const
 {
-    ASSERT(bp!=0);
+    GINAC_ASSERT(bp!=0);
     return bp->expand(options);
 }
 
-bool ex::has(ex const & other) const
+bool ex::has(const ex & other) const
 {
-    ASSERT(bp!=0);
+    GINAC_ASSERT(bp!=0);
     return bp->has(other);
 }
 
-int ex::degree(symbol const & s) const
+int ex::degree(const symbol & s) const
 {
-    ASSERT(bp!=0);
+    GINAC_ASSERT(bp!=0);
     return bp->degree(s);
 }
 
-int ex::ldegree(symbol const & s) const
+int ex::ldegree(const symbol & s) const
 {
-    ASSERT(bp!=0);
+    GINAC_ASSERT(bp!=0);
     return bp->ldegree(s);
 }
 
-ex ex::coeff(symbol const & s, int const n) const
+ex ex::coeff(const symbol & s, int n) const
 {
-    ASSERT(bp!=0);
+    GINAC_ASSERT(bp!=0);
     return bp->coeff(s,n);
 }
 
@@ -239,13 +316,13 @@ ex ex::numer(bool normalize) const
 
     // something^(-int)
     if (is_ex_exactly_of_type(n, power) && n.op(1).info(info_flags::negint))
-        return exONE();
+        return _ex1();
 
     // something^(int) * something^(int) * ...
     if (!is_ex_exactly_of_type(n, mul))
         return n;
-    ex res = exONE();
-    for (int i=0; i<n.nops(); i++) {
+    ex res = _ex1();
+    for (unsigned i=0; i<n.nops(); i++) {
         if (!is_ex_exactly_of_type(n.op(i), power) || !n.op(i).op(1).info(info_flags::negint))
             res *= n.op(i);
     }
@@ -262,7 +339,7 @@ ex ex::denom(bool normalize) const
 
     // polynomial
     if (n.info(info_flags::polynomial))
-        return exONE();
+        return _ex1();
 
     // something^(-int)
     if (is_ex_exactly_of_type(n, power) && n.op(1).info(info_flags::negint))
@@ -270,91 +347,106 @@ ex ex::denom(bool normalize) const
 
     // something^(int) * something^(int) * ...
     if (!is_ex_exactly_of_type(n, mul))
-        return exONE();
-    ex res = exONE();
-    for (int i=0; i<n.nops(); i++) {
+        return _ex1();
+    ex res = _ex1();
+    for (unsigned i=0; i<n.nops(); i++) {
         if (is_ex_exactly_of_type(n.op(i), power) && n.op(i).op(1).info(info_flags::negint))
             res *= power(n.op(i), -1);
     }
     return res;
 }
 
-ex ex::collect(symbol const & s) const
+ex ex::collect(const symbol & s) const
 {
-    ASSERT(bp!=0);
+    GINAC_ASSERT(bp!=0);
     return bp->collect(s);
 }
 
 ex ex::eval(int level) const
 {
-    ASSERT(bp!=0);
+    GINAC_ASSERT(bp!=0);
     return bp->eval(level);
 }
 
 ex ex::evalf(int level) const
 {
-    ASSERT(bp!=0);
+    GINAC_ASSERT(bp!=0);
     return bp->evalf(level);
 }
 
-ex ex::subs(lst const & ls, lst const & lr) const
+/** Compute partial derivative of an expression.
+ *
+ *  @param s  symbol by which the expression is derived
+ *  @param nth  order of derivative (default 1)
+ *  @return partial derivative as a new expression */
+ex ex::diff(const symbol & s, unsigned nth) const
+{
+    GINAC_ASSERT(bp!=0);
+
+    if (!nth)
+        return *this;
+    else
+        return bp->diff(s, nth);
+}
+
+ex ex::subs(const lst & ls, const lst & lr) const
 {
-    ASSERT(bp!=0);
+    GINAC_ASSERT(bp!=0);
     return bp->subs(ls,lr);
 }
 
-ex ex::subs(ex const & e) const
+ex ex::subs(const ex & e) const
 {
-    ASSERT(bp!=0);
+    GINAC_ASSERT(bp!=0);
     return bp->subs(e);
 }
 
 exvector ex::get_indices(void) const
 {
-    ASSERT(bp!=0);
+    GINAC_ASSERT(bp!=0);
     return bp->get_indices();
 }
 
-ex ex::simplify_ncmul(exvector const & v) const
+ex ex::simplify_ncmul(const exvector & v) const
 {
-    ASSERT(bp!=0);
+    GINAC_ASSERT(bp!=0);
     return bp->simplify_ncmul(v);
 }
 
-ex ex::operator[](ex const & index) const
+ex ex::operator[](const ex & index) const
 {
     debugmsg("ex operator[ex]",LOGLEVEL_OPERATOR);
-    ASSERT(bp!=0);
+    GINAC_ASSERT(bp!=0);
     return (*bp)[index];
 }
 
-ex ex::operator[](int const i) const
+ex ex::operator[](int i) const
 {
     debugmsg("ex operator[int]",LOGLEVEL_OPERATOR);
-    ASSERT(bp!=0);
+    GINAC_ASSERT(bp!=0);
     return (*bp)[i];
 }
 
-ex ex::op(int const i) const
+ex ex::op(int i) const
 {
     debugmsg("ex op()",LOGLEVEL_MEMBER_FUNCTION);
-    ASSERT(bp!=0);
+    GINAC_ASSERT(bp!=0);
     return bp->op(i);
 }
 
-ex & ex::let_op(int const i)
+ex & ex::let_op(int i)
 {
     debugmsg("ex let_op()",LOGLEVEL_MEMBER_FUNCTION);
     makewriteable();
-    ASSERT(bp!=0);
+    GINAC_ASSERT(bp!=0);
     return bp->let_op(i);
 }
 
 #ifndef INLINE_EX_CONSTRUCTORS
-int ex::compare(ex const & other) const
+int ex::compare(const ex & other) const
 {
-    ASSERT(bp!=0);
-    ASSERT(other.bp!=0);
+    GINAC_ASSERT(bp!=0);
+    GINAC_ASSERT(other.bp!=0);
     if (bp==other.bp) {
         // special case: both expression point to same basic, trivially equal
         return 0; 
@@ -364,10 +456,10 @@ int ex::compare(ex const & other) const
 #endif // ndef INLINE_EX_CONSTRUCTORS
 
 #ifndef INLINE_EX_CONSTRUCTORS
-bool ex::is_equal(ex const & other) const
+bool ex::is_equal(const ex & other) const
 {
-    ASSERT(bp!=0);
-    ASSERT(other.bp!=0);
+    GINAC_ASSERT(bp!=0);
+    GINAC_ASSERT(other.bp!=0);
     if (bp==other.bp) {
         // special case: both expression point to same basic, trivially equal
         return true; 
@@ -378,33 +470,33 @@ bool ex::is_equal(ex const & other) const
 
 unsigned ex::return_type(void) const
 {
-    ASSERT(bp!=0);
+    GINAC_ASSERT(bp!=0);
     return bp->return_type();
 }
 
 unsigned ex::return_type_tinfo(void) const
 {
-    ASSERT(bp!=0);
+    GINAC_ASSERT(bp!=0);
     return bp->return_type_tinfo();
 }
 
 unsigned ex::gethash(void) const
 {
-    ASSERT(bp!=0);
+    GINAC_ASSERT(bp!=0);
     return bp->gethash();
 }
 
-ex ex::exadd(ex const & rh) const
+ex ex::exadd(const ex & rh) const
 {
     return (new add(*this,rh))->setflag(status_flags::dynallocated);
 }
 
-ex ex::exmul(ex const & rh) const
+ex ex::exmul(const ex & rh) const
 {
     return (new mul(*this,rh))->setflag(status_flags::dynallocated);
 }
 
-ex ex::exncmul(ex const & rh) const
+ex ex::exncmul(const ex & rh) const
 {
     return (new ncmul(*this,rh))->setflag(status_flags::dynallocated);
 }
@@ -414,45 +506,182 @@ ex ex::exncmul(ex const & rh) const
 void ex::makewriteable()
 {
     debugmsg("ex makewriteable",LOGLEVEL_MEMBER_FUNCTION);
-    ASSERT(bp!=0);
-    ASSERT(bp->flags & status_flags::dynallocated);
+    GINAC_ASSERT(bp!=0);
+    GINAC_ASSERT(bp->flags & status_flags::dynallocated);
     if (bp->refcount > 1) {
-        basic * bp2=bp->duplicate();
+        basic * bp2 = bp->duplicate();
         ++bp2->refcount;
         bp2->setflag(status_flags::dynallocated);
         --bp->refcount;
-        bp=bp2;
+        bp = bp2;
     }
-    ASSERT(bp->refcount == 1);
-}    
+    GINAC_ASSERT(bp->refcount == 1);
+}
 
-void ex::construct_from_basic(basic const & other)
+void ex::construct_from_basic(const basic & other)
 {
-    if ( (other.flags & status_flags::evaluated)==0 ) {
+    if ((other.flags & status_flags::evaluated)==0) {
         // cf. copy constructor
-        ex const & tmpex = other.eval(1); // evaluate only one (top) level
+        const ex & tmpex = other.eval(1); // evaluate only one (top) level
         bp = tmpex.bp;
-        ASSERT(bp!=0);
-        ASSERT(bp->flags & status_flags::dynallocated);
+        GINAC_ASSERT(bp!=0);
+        GINAC_ASSERT(bp->flags & status_flags::dynallocated);
         ++bp->refcount;
         if ((other.flags & status_flags::dynallocated)&&(other.refcount==0)) {
             delete &const_cast<basic &>(other);
         }
     } else {
         if (other.flags & status_flags::dynallocated) {
-            bp=&const_cast<basic &>(other);
+            bp = &const_cast<basic &>(other);
         } else {
-            bp=other.duplicate();
+            bp = other.duplicate();
             bp->setflag(status_flags::dynallocated);
         }
-        ASSERT(bp!=0);
+        GINAC_ASSERT(bp!=0);
         // bp->clearflag(status_flags::evaluated);
         ++bp->refcount;
     }
-    ASSERT(bp!=0);
-    ASSERT(bp->flags & status_flags::dynallocated);
+    GINAC_ASSERT(bp!=0);
+    GINAC_ASSERT(bp->flags & status_flags::dynallocated);
 }
 
+void ex::construct_from_int(int i)
+{
+    switch (i) {  // some tiny efficiency-hack
+    case -2:
+        bp = _ex_2().bp;
+        ++bp->refcount;
+        break;
+    case -1:
+        bp = _ex_1().bp;
+        ++bp->refcount;
+        break;
+    case 0:
+        bp = _ex0().bp;
+        ++bp->refcount;
+        break;
+    case 1:
+        bp = _ex1().bp;
+        ++bp->refcount;
+        break;
+    case 2:
+        bp = _ex2().bp;
+        ++bp->refcount;
+        break;
+    default:
+        bp = new numeric(i);
+        bp->setflag(status_flags::dynallocated);
+        ++bp->refcount;
+        GINAC_ASSERT((bp->flags) & status_flags::dynallocated);
+        GINAC_ASSERT(bp->refcount=1);
+    }
+}
+    
+void ex::construct_from_uint(unsigned int i)
+{
+    switch (i) {  // some tiny efficiency-hack
+    case -2:
+        bp = _ex_2().bp;
+        ++bp->refcount;
+        break;
+    case -1:
+        bp = _ex_1().bp;
+        ++bp->refcount;
+        break;
+    case 0:
+        bp = _ex0().bp;
+        ++bp->refcount;
+        break;
+    case 1:
+        bp = _ex1().bp;
+        ++bp->refcount;
+        break;
+    case 2:
+        bp = _ex2().bp;
+        ++bp->refcount;
+        break;
+    default:
+        bp = new numeric(i);
+        bp->setflag(status_flags::dynallocated);
+        ++bp->refcount;
+        GINAC_ASSERT((bp->flags) & status_flags::dynallocated);
+        GINAC_ASSERT(bp->refcount=1);
+    }
+}
+    
+void ex::construct_from_long(long i)
+{
+    switch (i) {  // some tiny efficiency-hack
+    case -2:
+        bp = _ex_2().bp;
+        ++bp->refcount;
+        break;
+    case -1:
+        bp = _ex_1().bp;
+        ++bp->refcount;
+        break;
+    case 0:
+        bp = _ex0().bp;
+        ++bp->refcount;
+        break;
+    case 1:
+        bp = _ex1().bp;
+        ++bp->refcount;
+        break;
+    case 2:
+        bp = _ex2().bp;
+        ++bp->refcount;
+        break;
+    default:
+        bp = new numeric(i);
+        bp->setflag(status_flags::dynallocated);
+        ++bp->refcount;
+        GINAC_ASSERT((bp->flags) & status_flags::dynallocated);
+        GINAC_ASSERT(bp->refcount=1);
+    }
+}
+    
+void ex::construct_from_ulong(unsigned long i)
+{
+    switch (i) {  // some tiny efficiency-hack
+    case -2:
+        bp = _ex_2().bp;
+        ++bp->refcount;
+        break;
+    case -1:
+        bp = _ex_1().bp;
+        ++bp->refcount;
+        break;
+    case 0:
+        bp = _ex0().bp;
+        ++bp->refcount;
+        break;
+    case 1:
+        bp = _ex1().bp;
+        ++bp->refcount;
+        break;
+    case 2:
+        bp = _ex2().bp;
+        ++bp->refcount;
+        break;
+    default:
+        bp = new numeric(i);
+        bp->setflag(status_flags::dynallocated);
+        ++bp->refcount;
+        GINAC_ASSERT((bp->flags) & status_flags::dynallocated);
+        GINAC_ASSERT(bp->refcount=1);
+    }
+}
+    
+void ex::construct_from_double(double d)
+{
+    bp = new numeric(d);
+    bp->setflag(status_flags::dynallocated);
+    ++bp->refcount;
+    GINAC_ASSERT((bp->flags) & status_flags::dynallocated);
+    GINAC_ASSERT(bp->refcount=1);
+}
+    
 //////////
 // static member variables
 //////////
@@ -469,45 +698,9 @@ void ex::construct_from_basic(basic const & other)
 // global functions
 //////////
 
-ex const & exZERO(void)
-{
-    static ex * eZERO=new ex(numZERO());
-    return *eZERO;
-}
-
-ex const & exONE(void)
-{
-    static ex * eONE=new ex(numONE());
-    return *eONE;
-}
-
-ex const & exTWO(void)
-{
-    static ex * eTWO=new ex(numTWO());
-    return *eTWO;
-}
-
-ex const & exTHREE(void)
-{
-    static ex * eTHREE=new ex(numTHREE());
-    return *eTHREE;
-}
-
-ex const & exMINUSONE(void)
-{
-    static ex * eMINUSONE=new ex(numMINUSONE());
-    return *eMINUSONE;
-}
-
-ex const & exHALF(void)
-{
-    static ex * eHALF=new ex(ex(1)/ex(2));
-    return *eHALF;
-}
+// none
 
-ex const & exMINUSHALF(void)
-{
-    static ex * eMINUSHALF=new ex(numeric(-1,2));
-    return *eMINUSHALF;
-}
 
+#ifndef NO_NAMESPACE_GINAC
+} // namespace GiNaC
+#endif // ndef NO_NAMESPACE_GINAC