X-Git-Url: https://www.ginac.de/ginac.git//ginac.git?p=ginac.git;a=blobdiff_plain;f=ginac%2Fex.h;h=05f31573929d94b40f37c8580032123268b25118;hp=21a4ea7cbdaeb26a5c73ea654affecfd2c99cbda;hb=bd2d7351b89743eb68ce7d3bfa7ab62c331f9522;hpb=0a1b35cf1e59c9e3aae33de8febaa1c8f4bbe630

diff --git a/ginac/ex.h b/ginac/ex.h
index 21a4ea7c..05f31573 100644
--- a/ginac/ex.h
+++ b/ginac/ex.h
@@ -24,12 +24,12 @@
 #define __GINAC_EX_H__
 
 #include <iostream>
-#include <ginac/basic.h>
-#include <ginac/operators.h>
+#include "basic.h"
+#include "operators.h"
 
-#ifndef NO_GINAC_NAMESPACE
+#ifndef NO_NAMESPACE_GINAC
 namespace GiNaC {
-#endif // ndef NO_GINAC_NAMESPACE
+#endif // ndef NO_NAMESPACE_GINAC
 
 class ex;
 class expand_options;
@@ -38,9 +38,9 @@ class status_flags;
 class symbol;
 class lst;
 
-extern ex const & _ex0(void);  /* FIXME: should this pollute headers? */
-
-// typedef vector<ex> exvector;
+// Sorry, this is the only constant to pollute the global scope, the other ones
+// are defined in utils.h and not visible from outside.
+extern const ex & _ex0(void);     //  single ex(numeric(0))
 
 #define INLINE_EX_CONSTRUCTORS
 
@@ -84,7 +84,7 @@ public:
 ;
 #endif // def INLINE_EX_CONSTRUCTORS
         
-    ex(ex const & other)
+    ex(const ex & other)
 #ifdef INLINE_EX_CONSTRUCTORS
     : bp(other.bp)
         {
@@ -99,7 +99,7 @@ public:
 ;
 #endif // def INLINE_EX_CONSTRUCTORS
         
-    ex const & operator=(ex const & other)
+    const ex & operator=(const ex & other)
 #ifdef INLINE_EX_CONSTRUCTORS
         {
             GINAC_ASSERT(bp!=0);
@@ -121,9 +121,10 @@ public:
 ;
 #endif // def INLINE_EX_CONSTRUCTORS
 
+
     // other constructors
 public:
-    ex(basic const & other)
+    ex(const basic & other)
 #ifdef INLINE_EX_CONSTRUCTORS
         {
             construct_from_basic(other);
@@ -135,12 +136,83 @@ public:
 ;
 #endif // def INLINE_EX_CONSTRUCTORS
     
-    ex(int const i);
-    ex(unsigned int const i);
-    ex(long const i);
-    ex(unsigned long const i);
-    ex(double const d);
+    ex(int i)
+#ifdef INLINE_EX_CONSTRUCTORS
+        {
+            construct_from_int(i);
+#ifdef OBSCURE_CINT_HACK
+            update_last_created_or_assigned_bp();
+#endif // def OBSCURE_CINT_HACK
+        }
+#else
+;
+#endif // def INLINE_EX_CONSTRUCTORS
+
+    ex(unsigned int i)
+#ifdef INLINE_EX_CONSTRUCTORS
+        {
+            construct_from_uint(i);
+#ifdef OBSCURE_CINT_HACK
+            update_last_created_or_assigned_bp();
+#endif // def OBSCURE_CINT_HACK
+        }
+#else
+;
+#endif // def INLINE_EX_CONSTRUCTORS
+    
+    ex(long i)
+#ifdef INLINE_EX_CONSTRUCTORS
+        {
+            construct_from_long(i);
+#ifdef OBSCURE_CINT_HACK
+            update_last_created_or_assigned_bp();
+#endif // def OBSCURE_CINT_HACK
+        }
+#else
+;
+#endif // def INLINE_EX_CONSTRUCTORS
 
+    ex(unsigned long i)
+#ifdef INLINE_EX_CONSTRUCTORS
+        {
+            construct_from_ulong(i);
+#ifdef OBSCURE_CINT_HACK
+            update_last_created_or_assigned_bp();
+#endif // def OBSCURE_CINT_HACK
+        }
+#else
+;
+#endif // def INLINE_EX_CONSTRUCTORS
+    
+    ex(double const d)
+#ifdef INLINE_EX_CONSTRUCTORS
+        {
+            construct_from_double(d);
+#ifdef OBSCURE_CINT_HACK
+            update_last_created_or_assigned_bp();
+#endif // def OBSCURE_CINT_HACK
+        }
+#else
+;
+#endif // def INLINE_EX_CONSTRUCTORS
+
+    /** Construct ex from string and a list of symbols. The input grammar is
+     *  similar to the GiNaC output format. All symbols to be used in the
+     *  expression must be specified in a lst in the second argument. Undefined
+     *  symbols and other parser errors will throw an exception. */
+    ex(const std::string &s, const ex &l)
+#ifdef INLINE_EX_CONSTRUCTORS
+        {
+            construct_from_string_and_lst(s, l);
+#ifdef OBSCURE_CINT_HACK
+            update_last_created_or_assigned_bp();
+#endif // def OBSCURE_CINT_HACK
+        }
+#else
+;
+#endif // def INLINE_EX_CONSTRUCTORS
+
+    
     // functions overriding virtual functions from bases classes
     // none
     
@@ -150,45 +222,48 @@ public:
     // non-virtual functions in this class
 public:
     void swap(ex & other);
-    void printraw(ostream & os) const;
-    void printtree(ostream & os, unsigned indent=0) const;
-    void print(ostream & os, unsigned upper_precedence=0) const;
-    void printcsrc(ostream & os, unsigned type, const char *var_name) const;
+    void printraw(std::ostream & os) const;
+    void printtree(std::ostream & os, unsigned indent=0) const;
+    void print(std::ostream & os, unsigned upper_precedence=0) const;
+    void printcsrc(std::ostream & os, unsigned type, const char *var_name) const;
     void dbgprint(void) const;
     void dbgprinttree(void) const;
     bool info(unsigned inf) const;
     unsigned nops() const;
     ex expand(unsigned options=0) const;
-    bool has(ex const & other) const;
-    int degree(symbol const & s) const;
-    int ldegree(symbol const & s) const;
-    ex coeff(symbol const & s, int const n=1) const;
-    ex lcoeff(symbol const & s) const { return coeff(s, degree(s)); }
-    ex tcoeff(symbol const & s) const { return coeff(s, ldegree(s)); }
-    ex numer(bool normalize = true) const;
-    ex denom(bool normalize = true) const;
+    bool has(const ex & other) const;
+    int degree(const symbol & s) const;
+    int ldegree(const symbol & s) const;
+    ex coeff(const symbol & s, int n=1) const;
+    ex lcoeff(const symbol & s) const { return coeff(s, degree(s)); }
+    ex tcoeff(const symbol & s) const { return coeff(s, ldegree(s)); }
+    ex numer(void) const;
+    ex denom(void) const;
     ex unit(const symbol &x) const;
     ex content(const symbol &x) const;
     numeric integer_content(void) const;
     ex primpart(const symbol &x) const;
     ex primpart(const symbol &x, const ex &cont) const;
     ex normal(int level = 0) const;
+    ex to_rational(lst &repl_lst) const;
     ex smod(const numeric &xi) const;
     numeric max_coefficient(void) const;
-    ex collect(symbol const & s) const;
+    ex collect(const symbol & s) const;
     ex eval(int level = 0) const;
     ex evalf(int level = 0) const;
-    ex diff(symbol const & s, unsigned nth = 1) const;
-    ex series(symbol const & s, ex const & point, int order = 6) const;
-    ex subs(lst const & ls, lst const & lr) const;
-    ex subs(ex const & e) const;
+    ex diff(const symbol & s, unsigned nth = 1) const;
+    ex series(const ex & r, int order, bool branchcut = true) const;
+    ex subs(const lst & ls, const lst & lr) const;
+    ex subs(const ex & e) const;
     exvector get_indices(void) const;
-    ex simplify_ncmul(exvector const & v) const;
-    ex operator[](ex const & index) const;
-    ex operator[](int const i) const;
-    ex op(int const i) const;
-    ex & let_op(int const i);
-    int compare(ex const & other) const
+    ex simplify_ncmul(const exvector & v) const;
+    ex operator[](const ex & index) const;
+    ex operator[](int i) const;
+    ex op(int i) const;
+    ex & let_op(int i);
+    ex lhs(void) const;
+    ex rhs(void) const;
+    int compare(const ex & other) const
 #ifdef INLINE_EX_CONSTRUCTORS
         {
             GINAC_ASSERT(bp!=0);
@@ -202,7 +277,7 @@ public:
 #else
 ;
 #endif // def INLINE_EX_CONSTRUCTORS
-    bool is_equal(ex const & other) const
+    bool is_equal(const ex & other) const
 #ifdef INLINE_EX_CONSTRUCTORS
         {
             GINAC_ASSERT(bp!=0);
@@ -222,11 +297,17 @@ public:
     unsigned return_type_tinfo(void) const;
     unsigned gethash(void) const;
 
-    ex exadd(ex const & rh) const;
-    ex exmul(ex const & rh) const;
-    ex exncmul(ex const & rh) const;
+    ex exadd(const ex & rh) const;
+    ex exmul(const ex & rh) const;
+    ex exncmul(const ex & rh) const;
 private:
-    void construct_from_basic(basic const & other);
+    void construct_from_basic(const basic & other);
+    void construct_from_int(int i);
+    void construct_from_uint(unsigned int i);
+    void construct_from_long(long i);
+    void construct_from_ulong(unsigned long i);
+    void construct_from_double(double d);
+    void construct_from_string_and_lst(const std::string &s, const ex &l);
     void makewriteable();
 
 #ifdef OBSCURE_CINT_HACK
@@ -250,6 +331,7 @@ protected:
             }
             last_created_or_assigned_bp=bp;
             ++last_created_or_assigned_bp->refcount;
+            last_created_or_assigned_exp=(long)(void *)(this);
         }
 #endif // def OBSCURE_CINT_HACK
 
@@ -258,7 +340,9 @@ protected:
 public:
     basic *bp;
 #ifdef OBSCURE_CINT_HACK
-    static basic *last_created_or_assigned_bp;
+    static basic * last_created_or_assigned_bp;
+    static basic * dummy_bp;
+    static long last_created_or_assigned_exp;
 #endif // def OBSCURE_CINT_HACK
 };
 
@@ -269,60 +353,75 @@ inline bool are_ex_trivially_equal(const ex &e1, const ex &e2)
 }
 
 // wrapper functions around member functions
-inline unsigned nops(ex const & thisex)
+inline unsigned nops(const ex & thisex)
 { return thisex.nops(); }
 
-inline ex expand(ex const & thisex, unsigned options = 0)
+inline ex expand(const ex & thisex, unsigned options = 0)
 { return thisex.expand(options); }
 
-inline bool has(ex const & thisex, ex const & other)
+inline bool has(const ex & thisex, const ex & other)
 { return thisex.has(other); }
 
-inline int degree(ex const & thisex, symbol const & s)
+inline int degree(const ex & thisex, const symbol & s)
 { return thisex.degree(s); }
 
-inline int ldegree(ex const & thisex, symbol const & s)
+inline int ldegree(const ex & thisex, const symbol & s)
 { return thisex.ldegree(s); }
 
-inline ex coeff(ex const & thisex, symbol const & s, int const n=1)
+inline ex coeff(const ex & thisex, const symbol & s, int n=1)
 { return thisex.coeff(s, n); }
 
-inline ex numer(ex const & thisex, bool normalize = true)
-{ return thisex.numer(normalize); }
+inline ex numer(const ex & thisex)
+{ return thisex.numer(); }
 
-inline ex denom(ex const & thisex, bool normalize = true)
-{ return thisex.denom(normalize); }
+inline ex denom(const ex & thisex)
+{ return thisex.denom(); }
 
-inline ex normal(ex const & thisex, int level=0)
+inline ex normal(const ex & thisex, int level=0)
 { return thisex.normal(level); }
 
-inline ex collect(ex const & thisex, symbol const & s)
+inline ex to_rational(const ex & thisex, lst & repl_lst)
+{ return thisex.to_rational(repl_lst); }
+
+inline ex collect(const ex & thisex, const symbol & s)
 { return thisex.collect(s); }
 
-inline ex eval(ex const & thisex, int level = 0)
+inline ex eval(const ex & thisex, int level = 0)
 { return thisex.eval(level); }
 
-inline ex evalf(ex const & thisex, int level = 0)
+inline ex evalf(const ex & thisex, int level = 0)
 { return thisex.evalf(level); }
 
-inline ex diff(ex const & thisex, symbol const & s, unsigned nth = 1)
+inline ex diff(const ex & thisex, const symbol & s, unsigned nth = 1)
 { return thisex.diff(s, nth); }
 
-inline ex series(ex const & thisex, symbol const & s, ex const & point, int order = 6)
-{ return thisex.series(s, point, order); }
+inline ex series(const ex & thisex, const ex & r, int order, bool branchcut = true)
+{ return thisex.series(r, order, branchcut); }
 
-inline ex subs(ex const & thisex, ex const & e)
+inline ex subs(const ex & thisex, const ex & e)
 { return thisex.subs(e); }
 
-inline ex subs(ex const & thisex, lst const & ls, lst const & lr)
+inline ex subs(const ex & thisex, const lst & ls, const lst & lr)
 { return thisex.subs(ls, lr); }
 
+inline ex op(const ex & thisex, int i)
+{ return thisex.op(i); }
+
+inline ex lhs(const ex & thisex)
+{ return thisex.lhs(); }
+
+inline ex rhs(const ex & thisex)
+{ return thisex.rhs(); }
+
+inline bool is_zero(const ex & thisex)
+{ return thisex.is_zero(); }
+
 inline void swap(ex & e1, ex & e2)
 { e1.swap(e2); }
 
-#ifndef NO_GINAC_NAMESPACE
+#ifndef NO_NAMESPACE_GINAC
 } // namespace GiNaC
-#endif // ndef NO_GINAC_NAMESPACE
+#endif // ndef NO_NAMESPACE_GINAC
 
 #endif // ndef __GINAC_EX_H__