X-Git-Url: https://www.ginac.de/ginac.git//ginac.git?p=ginac.git;a=blobdiff_plain;f=ginac%2Fex.cpp;h=23a30833b5a436375918e34358a4208376cf00d6;hp=652005ddfc4d815c940c0ee204718892adc051f8;hb=a32a30d8ccdd0eb945b8180c8fe82d154e9280de;hpb=a8507b8af1c08d9b27d98d57f95c7ca1a8671e27

diff --git a/ginac/ex.cpp b/ginac/ex.cpp
index 652005dd..23a30833 100644
--- a/ginac/ex.cpp
+++ b/ginac/ex.cpp
@@ -1,8 +1,9 @@
 /** @file ex.cpp
  *
- *  Implementation of GiNaC's light-weight expression handles.
- *
- *  GiNaC Copyright (C) 1999 Johannes Gutenberg University Mainz, Germany
+ *  Implementation of GiNaC's light-weight expression handles. */
+
+/*
+ *  GiNaC Copyright (C) 1999-2008 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
@@ -16,437 +17,555 @@
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  */
 
 #include <iostream>
-
-#include "ginac.h"
-
-//////////
-// default constructor, destructor, copy constructor assignment operator and helpers
-//////////
-
-// public
-
-#ifndef INLINE_EX_CONSTRUCTORS
-
-ex::ex() : bp(exZERO().bp)
-{
-    debugmsg("ex default constructor",LOGLEVEL_CONSTRUCT);
-    ASSERT(exZERO().bp!=0);
-    ASSERT(exZERO().bp->flags & status_flags::dynallocated);
-    ASSERT(bp!=0);
-    ++bp->refcount;
-}
-
-ex::~ex()
-{
-    debugmsg("ex destructor",LOGLEVEL_DESTRUCT);
-    ASSERT(bp!=0);
-    ASSERT(bp->flags & status_flags::dynallocated);
-    if (--bp->refcount == 0) {
-        delete bp;
-    }
-}
-
-ex::ex(ex const & other) : bp(other.bp)
-{
-    debugmsg("ex copy constructor",LOGLEVEL_CONSTRUCT);
-    ASSERT(bp!=0);
-    ASSERT((bp->flags) & status_flags::dynallocated);
-    ++bp->refcount;
-}
-
-ex const & ex::operator=(ex const & 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);
-    ++other.bp->refcount;
-    basic * tmpbp=other.bp;
-    if (--bp->refcount==0) {
-            delete bp;
-    }
-    bp=tmpbp;
-    return *this;
-}
-
-#endif // ndef INLINE_EX_CONSTRUCTORS
+#include <stdexcept>
+
+#include "ex.h"
+#include "add.h"
+#include "mul.h"
+#include "ncmul.h"
+#include "numeric.h"
+#include "matrix.h"
+#include "power.h"
+#include "lst.h"
+#include "relational.h"
+#include "input_lexer.h"
+#include "utils.h"
+
+namespace GiNaC {
 
 //////////
 // other constructors
 //////////
 
-// public
-
-#ifndef INLINE_EX_CONSTRUCTORS
-ex::ex(basic const & other)
-{
-    debugmsg("ex constructor from basic",LOGLEVEL_CONSTRUCT);
-    construct_from_basic(other);
-}
-#endif
-
-ex::ex(int const i)
-{
-    debugmsg("ex constructor from int",LOGLEVEL_CONSTRUCT);
-    construct_from_basic(numeric(i));
-}
-
-ex::ex(unsigned int const i)
-{
-    debugmsg("ex constructor from unsigned int",LOGLEVEL_CONSTRUCT);
-    construct_from_basic(numeric(i));
-}
-
-ex::ex(long const i)
-{
-    debugmsg("ex constructor from long",LOGLEVEL_CONSTRUCT);
-    construct_from_basic(numeric(i));
-}
-
-ex::ex(unsigned long const i)
-{
-    debugmsg("ex constructor from unsigned long",LOGLEVEL_CONSTRUCT);
-    construct_from_basic(numeric(i));
-}
-
-ex::ex(double const d)
-{
-    debugmsg("ex constructor from double",LOGLEVEL_CONSTRUCT);
-    construct_from_basic(numeric(d));
-}
-    
-//////////
-// functions overriding virtual functions from bases classes
-//////////
-
-// none
-
-//////////
-// new virtual functions which can be overridden by derived classes
-//////////
-
-// none
+// none (all inlined)
 
 //////////
 // non-virtual functions in this class
 //////////
 
 // public
-
-void ex::swap(ex & other)
+	
+/** Print expression to stream. The formatting of the output is determined
+ *  by the kind of print_context object that is passed. Possible formattings
+ *  include ginsh-parsable output (the default), tree-like output for
+ *  debugging, and C++ source.
+ *  @see print_context */
+void ex::print(const print_context & c, unsigned level) const
 {
-    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);
-    
-    basic * tmpbp=bp;
-    bp=other.bp;
-    other.bp=tmpbp;
+	bp->print(c, level);
 }
 
-bool ex::info(unsigned inf) const
+/** Little wrapper arount print to be called within a debugger. */
+void ex::dbgprint() const
 {
-    if (inf == info_flags::normal_form) {
-
-    // Polynomials are in normal form
-    if (info(info_flags::polynomial))
-        return true;
-
-    // polynomial^(-int) is in normal form
-    if (is_ex_exactly_of_type(*this, power))
-        return op(1).info(info_flags::negint);
-
-    // 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++) {
-        if (is_ex_exactly_of_type(op(i), power)) {
-            if (!op(i).op(1).info(info_flags::integer))
-                return false;
-            if (!op(i).op(0).info(info_flags::polynomial))
-                return false;
-        } else
-            if (!op(i).info(info_flags::polynomial))
-                return false;
-    }
-    return true;
-    } else {
-        return bp->info(inf);
-    }
+	bp->dbgprint();
 }
 
-int ex::nops() const
+/** Little wrapper arount printtree to be called within a debugger. */
+void ex::dbgprinttree() const
 {
-    ASSERT(bp!=0);
-    return bp->nops();
+	bp->dbgprinttree();
 }
 
 ex ex::expand(unsigned options) const
 {
-    ASSERT(bp!=0);
-    return bp->expand(options);
+	if (options == 0 && (bp->flags & status_flags::expanded)) // The "expanded" flag only covers the standard options; someone might want to re-expand with different options
+		return *this;
+	else
+		return bp->expand(options);
 }
 
-bool ex::has(ex const & other) 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
 {
-    ASSERT(bp!=0);
-    return bp->has(other);
+	if (!nth)
+		return *this;
+	else
+		return bp->diff(s, nth);
 }
 
-int ex::degree(symbol const & s) const
+/** Check whether expression matches a specified pattern. */
+bool ex::match(const ex & pattern) const
 {
-    ASSERT(bp!=0);
-    return bp->degree(s);
+	lst repl_lst;
+	return bp->match(pattern, repl_lst);
 }
 
-int ex::ldegree(symbol const & s) const
+/** Find all occurrences of a pattern. The found matches are appended to
+ *  the "found" list. If the expression itself matches the pattern, the
+ *  children are not further examined. This function returns true when any
+ *  matches were found. */
+bool ex::find(const ex & pattern, lst & found) const
 {
-    ASSERT(bp!=0);
-    return bp->ldegree(s);
+	if (match(pattern)) {
+		found.append(*this);
+		found.sort();
+		found.unique();
+		return true;
+	}
+	bool any_found = false;
+	for (size_t i=0; i<nops(); i++)
+		if (op(i).find(pattern, found))
+			any_found = true;
+	return any_found;
 }
 
-ex ex::coeff(symbol const & s, int const n) const
+/** Substitute objects in an expression (syntactic substitution) and return
+ *  the result as a new expression. */
+ex ex::subs(const lst & ls, const lst & lr, unsigned options) const
 {
-    ASSERT(bp!=0);
-    return bp->coeff(s,n);
-}
+	GINAC_ASSERT(ls.nops() == lr.nops());
 
-ex ex::numer(bool normalize) const
-{
-    ex n;
-    if (normalize && !info(info_flags::normal_form))
-        n = normal();
-    else
-        n = *this;
-
-    // polynomial
-    if (n.info(info_flags::polynomial))
-        return n;
-
-    // something^(-int)
-    if (is_ex_exactly_of_type(n, power) && n.op(1).info(info_flags::negint))
-        return exONE();
-
-    // 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++) {
-        if (!is_ex_exactly_of_type(n.op(i), power) || !n.op(i).op(1).info(info_flags::negint))
-            res *= n.op(i);
-    }
-    return res;
-}
+	// Convert the lists to a map
+	exmap m;
+	for (lst::const_iterator its = ls.begin(), itr = lr.begin(); its != ls.end(); ++its, ++itr) {
+		m.insert(std::make_pair(*its, *itr));
 
-ex ex::denom(bool normalize) const
-{
-    ex n;
-    if (normalize && !info(info_flags::normal_form))
-        n = normal();
-    else
-        n = *this;
-
-    // polynomial
-    if (n.info(info_flags::polynomial))
-        return exONE();
-
-    // something^(-int)
-    if (is_ex_exactly_of_type(n, power) && n.op(1).info(info_flags::negint))
-        return power(n.op(0), -(n.op(1)));
-
-    // 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++) {
-        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;
-}
+		// Search for products and powers in the expressions to be substituted
+		// (for an optimization in expairseq::subs())
+		if (is_exactly_a<mul>(*its) || is_exactly_a<power>(*its))
+			options |= subs_options::pattern_is_product;
+	}
+	if (!(options & subs_options::pattern_is_product))
+		options |= subs_options::pattern_is_not_product;
 
-ex ex::collect(symbol const & s) const
-{
-    ASSERT(bp!=0);
-    return bp->collect(s);
+	return bp->subs(m, options);
 }
 
-ex ex::eval(int level) const
+/** Substitute objects in an expression (syntactic substitution) and return
+ *  the result as a new expression.  There are two valid types of
+ *  replacement arguments: 1) a relational like object==ex and 2) a list of
+ *  relationals lst(object1==ex1,object2==ex2,...). */
+ex ex::subs(const ex & e, unsigned options) const
 {
-    ASSERT(bp!=0);
-    return bp->eval(level);
-}
+	if (e.info(info_flags::relation_equal)) {
 
-ex ex::evalf(int level) const
-{
-    ASSERT(bp!=0);
-    return bp->evalf(level);
-}
+		// Argument is a relation: convert it to a map
+		exmap m;
+		const ex & s = e.op(0);
+		m.insert(std::make_pair(s, e.op(1)));
 
-ex ex::subs(lst const & ls, lst const & lr) const
-{
-    ASSERT(bp!=0);
-    return bp->subs(ls,lr);
-}
+		if (is_exactly_a<mul>(s) || is_exactly_a<power>(s))
+			options |= subs_options::pattern_is_product;
+		else
+			options |= subs_options::pattern_is_not_product;
 
-ex ex::subs(ex const & e) const
-{
-    ASSERT(bp!=0);
-    return bp->subs(e);
-}
+		return bp->subs(m, options);
 
-exvector ex::get_indices(void) const
-{
-    ASSERT(bp!=0);
-    return bp->get_indices();
-}
+	} else if (e.info(info_flags::list)) {
 
-ex ex::simplify_ncmul(exvector const & v) const
-{
-    ASSERT(bp!=0);
-    return bp->simplify_ncmul(v);
-}
+		// Argument is a list: convert it to a map
+		exmap m;
+		GINAC_ASSERT(is_a<lst>(e));
+		for (lst::const_iterator it = ex_to<lst>(e).begin(); it != ex_to<lst>(e).end(); ++it) {
+			ex r = *it;
+			if (!r.info(info_flags::relation_equal))
+				throw(std::invalid_argument("basic::subs(ex): argument must be a list of equations"));
+			const ex & s = r.op(0);
+			m.insert(std::make_pair(s, r.op(1)));
 
-ex ex::operator[](ex const & index) const
-{
-    debugmsg("ex operator[ex]",LOGLEVEL_OPERATOR);
-    ASSERT(bp!=0);
-    return (*bp)[index];
-}
+			// Search for products and powers in the expressions to be substituted
+			// (for an optimization in expairseq::subs())
+			if (is_exactly_a<mul>(s) || is_exactly_a<power>(s))
+				options |= subs_options::pattern_is_product;
+		}
+		if (!(options & subs_options::pattern_is_product))
+			options |= subs_options::pattern_is_not_product;
 
-ex ex::operator[](int const i) const
-{
-    debugmsg("ex operator[int]",LOGLEVEL_OPERATOR);
-    ASSERT(bp!=0);
-    return (*bp)[i];
-}
+		return bp->subs(m, options);
 
-ex ex::op(int const i) const
-{
-    debugmsg("ex op()",LOGLEVEL_MEMBER_FUNCTION);
-    ASSERT(bp!=0);
-    return bp->op(i);
+	} else
+		throw(std::invalid_argument("ex::subs(ex): argument must be a relation_equal or a list"));
 }
 
-ex & ex::let_op(int const i)
+/** Traverse expression tree with given visitor, preorder traversal. */
+void ex::traverse_preorder(visitor & v) const
 {
-    debugmsg("ex let_op()",LOGLEVEL_MEMBER_FUNCTION);
-    makewriteable();
-    ASSERT(bp!=0);
-    return bp->let_op(i);
+	accept(v);
+
+	size_t n = nops();
+	for (size_t i = 0; i < n; ++i)
+		op(i).traverse_preorder(v);
 }
 
-#ifndef INLINE_EX_CONSTRUCTORS
-int ex::compare(ex const & other) const
+/** Traverse expression tree with given visitor, postorder traversal. */
+void ex::traverse_postorder(visitor & v) const
 {
-    ASSERT(bp!=0);
-    ASSERT(other.bp!=0);
-    if (bp==other.bp) {
-        // special case: both expression point to same basic, trivially equal
-        return 0; 
-    }
-    return bp->compare(*other.bp);
+	size_t n = nops();
+	for (size_t i = 0; i < n; ++i)
+		op(i).traverse_postorder(v);
+
+	accept(v);
 }
-#endif // ndef INLINE_EX_CONSTRUCTORS
 
-#ifndef INLINE_EX_CONSTRUCTORS
-bool ex::is_equal(ex const & other) const
+/** Return modifyable operand/member at position i. */
+ex & ex::let_op(size_t i)
 {
-    ASSERT(bp!=0);
-    ASSERT(other.bp!=0);
-    if (bp==other.bp) {
-        // special case: both expression point to same basic, trivially equal
-        return true; 
-    }
-    return bp->is_equal(*other.bp);
+	makewriteable();
+	return bp->let_op(i);
 }
-#endif // ndef INLINE_EX_CONSTRUCTORS
 
-unsigned ex::return_type(void) const
+ex & ex::operator[](const ex & index)
 {
-    ASSERT(bp!=0);
-    return bp->return_type();
+	makewriteable();
+	return (*bp)[index];
 }
 
-unsigned ex::return_type_tinfo(void) const
+ex & ex::operator[](size_t i)
 {
-    ASSERT(bp!=0);
-    return bp->return_type_tinfo();
+	makewriteable();
+	return (*bp)[i];
 }
 
-unsigned ex::gethash(void) const
+/** Left hand side of relational expression. */
+ex ex::lhs() const
 {
-    ASSERT(bp!=0);
-    return bp->gethash();
+	if (!is_a<relational>(*this))
+		throw std::runtime_error("ex::lhs(): not a relation");
+	return bp->op(0);
 }
 
-ex ex::exadd(ex const & rh) const
+/** Right hand side of relational expression. */
+ex ex::rhs() const
 {
-    return (new add(*this,rh))->setflag(status_flags::dynallocated);
+	if (!is_a<relational>(*this))
+		throw std::runtime_error("ex::rhs(): not a relation");
+	return bp->op(1);
 }
 
-ex ex::exmul(ex const & rh) const
+/** Check whether expression is a polynomial. */
+bool ex::is_polynomial(const ex & vars) const
 {
-    return (new mul(*this,rh))->setflag(status_flags::dynallocated);
+	if (is_a<lst>(vars)) {
+		const lst & varlst = ex_to<lst>(vars);
+		for (lst::const_iterator i=varlst.begin(); i!=varlst.end(); ++i)
+			if (!bp->is_polynomial(*i))
+				return false;
+		return true;
+	}
+	else
+		return bp->is_polynomial(vars);
 }
 
-ex ex::exncmul(ex const & rh) const
+/** Check whether expression is zero or zero matrix. */
+bool ex::is_zero_matrix() const
 {
-    return (new ncmul(*this,rh))->setflag(status_flags::dynallocated);
+	if (is_zero())
+		return  true;
+	else {
+		ex e = evalm();
+		return is_a<matrix>(e) && ex_to<matrix>(e).is_zero_matrix();
+	}
 }
 
 // private
 
+/** Make this ex writable (if more than one ex handle the same basic) by 
+ *  unlinking the object and creating an unshared copy of it. */
 void ex::makewriteable()
 {
-    debugmsg("ex makewriteable",LOGLEVEL_MEMBER_FUNCTION);
-    ASSERT(bp!=0);
-    ASSERT(bp->flags & status_flags::dynallocated);
-    if (bp->refcount > 1) {
-        basic * bp2=bp->duplicate();
-        ++bp2->refcount;
-        bp2->setflag(status_flags::dynallocated);
-        --bp->refcount;
-        bp=bp2;
-    }
-    ASSERT(bp->refcount == 1);
-}    
-
-void ex::construct_from_basic(basic const & other)
-{
-    if ( (other.flags & status_flags::evaluated)==0 ) {
-        // cf. copy constructor
-        ex const & tmpex = other.eval(1); // evaluate only one (top) level
-        bp = tmpex.bp;
-        ASSERT(bp!=0);
-        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);
-        } else {
-            bp=other.duplicate();
-            bp->setflag(status_flags::dynallocated);
-        }
-        ASSERT(bp!=0);
-        // bp->clearflag(status_flags::evaluated);
-        ++bp->refcount;
-    }
-    ASSERT(bp!=0);
-    ASSERT(bp->flags & status_flags::dynallocated);
-}
-
+	GINAC_ASSERT(bp->flags & status_flags::dynallocated);
+	bp.makewritable();
+	GINAC_ASSERT(bp->get_refcount() == 1);
+}
+
+/** Share equal objects between expressions.
+ *  @see ex::compare(const ex &) */
+void ex::share(const ex & other) const
+{
+	if ((bp->flags | other.bp->flags) & status_flags::not_shareable)
+		return;
+
+	if (bp->get_refcount() <= other.bp->get_refcount())
+		bp = other.bp;
+	else
+		other.bp = bp;
+}
+
+/** Helper function for the ex-from-basic constructor. This is where GiNaC's
+ *  automatic evaluator and memory management are implemented.
+ *  @see ex::ex(const basic &) */
+ptr<basic> ex::construct_from_basic(const basic & other)
+{
+	if (!(other.flags & status_flags::evaluated)) {
+
+		// The object is not yet evaluated, so call eval() to evaluate
+		// the top level. This will return either
+		//  a) the original object with status_flags::evaluated set (when the
+		//     eval() implementation calls hold())
+		// or
+		//  b) a different expression.
+		//
+		// eval() returns an ex, not a basic&, so this will go through
+		// construct_from_basic() a second time. In case a) we end up in
+		// the "else" branch below. In case b) we end up here again and
+		// apply eval() once more. The recursion stops when eval() calls
+		// hold() or returns an object that already has its "evaluated"
+		// flag set, such as a symbol or a numeric.
+		const ex & tmpex = other.eval(1);
+
+		// Eventually, the eval() recursion goes through the "else" branch
+		// below, which assures that the object pointed to by tmpex.bp is
+		// allocated on the heap (either it was already on the heap or it
+		// is a heap-allocated duplicate of another object).
+		GINAC_ASSERT(tmpex.bp->flags & status_flags::dynallocated); 
+
+		// If the original object is not referenced but heap-allocated,
+		// it means that eval() hit case b) above. The original object is
+		// no longer needed (it evaluated into something different), so we
+		// delete it (because nobody else will).
+		if ((other.get_refcount() == 0) && (other.flags & status_flags::dynallocated))
+			delete &other; // yes, you can apply delete to a const pointer
+
+		// We can't return a basic& here because the tmpex is destroyed as
+		// soon as we leave the function, which would deallocate the
+		// evaluated object.
+		return tmpex.bp;
+
+	} else {
+
+		// The easy case: making an "ex" out of an evaluated object.
+		if (other.flags & status_flags::dynallocated) {
+
+			// The object is already heap-allocated, so we can just make
+			// another reference to it.
+			return ptr<basic>(const_cast<basic &>(other));
+
+		} else {
+
+			// The object is not heap-allocated, so we create a duplicate
+			// on the heap.
+			basic *bp = other.duplicate();
+			bp->setflag(status_flags::dynallocated);
+			GINAC_ASSERT(bp->get_refcount() == 0);
+			return bp;
+		}
+	}
+}
+
+basic & ex::construct_from_int(int i)
+{
+	switch (i) {  // prefer flyweights over new objects
+	case -12:
+		return *const_cast<numeric *>(_num_12_p);
+	case -11:
+		return *const_cast<numeric *>(_num_11_p);
+	case -10:
+		return *const_cast<numeric *>(_num_10_p);
+	case -9:
+		return *const_cast<numeric *>(_num_9_p);
+	case -8:
+		return *const_cast<numeric *>(_num_8_p);
+	case -7:
+		return *const_cast<numeric *>(_num_7_p);
+	case -6:
+		return *const_cast<numeric *>(_num_6_p);
+	case -5:
+		return *const_cast<numeric *>(_num_5_p);
+	case -4:
+		return *const_cast<numeric *>(_num_4_p);
+	case -3:
+		return *const_cast<numeric *>(_num_3_p);
+	case -2:
+		return *const_cast<numeric *>(_num_2_p);
+	case -1:
+		return *const_cast<numeric *>(_num_1_p);
+	case 0:
+		return *const_cast<numeric *>(_num0_p);
+	case 1:
+		return *const_cast<numeric *>(_num1_p);
+	case 2:
+		return *const_cast<numeric *>(_num2_p);
+	case 3:
+		return *const_cast<numeric *>(_num3_p);
+	case 4:
+		return *const_cast<numeric *>(_num4_p);
+	case 5:
+		return *const_cast<numeric *>(_num5_p);
+	case 6:
+		return *const_cast<numeric *>(_num6_p);
+	case 7:
+		return *const_cast<numeric *>(_num7_p);
+	case 8:
+		return *const_cast<numeric *>(_num8_p);
+	case 9:
+		return *const_cast<numeric *>(_num9_p);
+	case 10:
+		return *const_cast<numeric *>(_num10_p);
+	case 11:
+		return *const_cast<numeric *>(_num11_p);
+	case 12:
+		return *const_cast<numeric *>(_num12_p);
+	default:
+		basic *bp = new numeric(i);
+		bp->setflag(status_flags::dynallocated);
+		GINAC_ASSERT(bp->get_refcount() == 0);
+		return *bp;
+	}
+}
+	
+basic & ex::construct_from_uint(unsigned int i)
+{
+	switch (i) {  // prefer flyweights over new objects
+	case 0:
+		return *const_cast<numeric *>(_num0_p);
+	case 1:
+		return *const_cast<numeric *>(_num1_p);
+	case 2:
+		return *const_cast<numeric *>(_num2_p);
+	case 3:
+		return *const_cast<numeric *>(_num3_p);
+	case 4:
+		return *const_cast<numeric *>(_num4_p);
+	case 5:
+		return *const_cast<numeric *>(_num5_p);
+	case 6:
+		return *const_cast<numeric *>(_num6_p);
+	case 7:
+		return *const_cast<numeric *>(_num7_p);
+	case 8:
+		return *const_cast<numeric *>(_num8_p);
+	case 9:
+		return *const_cast<numeric *>(_num9_p);
+	case 10:
+		return *const_cast<numeric *>(_num10_p);
+	case 11:
+		return *const_cast<numeric *>(_num11_p);
+	case 12:
+		return *const_cast<numeric *>(_num12_p);
+	default:
+		basic *bp = new numeric(i);
+		bp->setflag(status_flags::dynallocated);
+		GINAC_ASSERT(bp->get_refcount() == 0);
+		return *bp;
+	}
+}
+	
+basic & ex::construct_from_long(long i)
+{
+	switch (i) {  // prefer flyweights over new objects
+	case -12:
+		return *const_cast<numeric *>(_num_12_p);
+	case -11:
+		return *const_cast<numeric *>(_num_11_p);
+	case -10:
+		return *const_cast<numeric *>(_num_10_p);
+	case -9:
+		return *const_cast<numeric *>(_num_9_p);
+	case -8:
+		return *const_cast<numeric *>(_num_8_p);
+	case -7:
+		return *const_cast<numeric *>(_num_7_p);
+	case -6:
+		return *const_cast<numeric *>(_num_6_p);
+	case -5:
+		return *const_cast<numeric *>(_num_5_p);
+	case -4:
+		return *const_cast<numeric *>(_num_4_p);
+	case -3:
+		return *const_cast<numeric *>(_num_3_p);
+	case -2:
+		return *const_cast<numeric *>(_num_2_p);
+	case -1:
+		return *const_cast<numeric *>(_num_1_p);
+	case 0:
+		return *const_cast<numeric *>(_num0_p);
+	case 1:
+		return *const_cast<numeric *>(_num1_p);
+	case 2:
+		return *const_cast<numeric *>(_num2_p);
+	case 3:
+		return *const_cast<numeric *>(_num3_p);
+	case 4:
+		return *const_cast<numeric *>(_num4_p);
+	case 5:
+		return *const_cast<numeric *>(_num5_p);
+	case 6:
+		return *const_cast<numeric *>(_num6_p);
+	case 7:
+		return *const_cast<numeric *>(_num7_p);
+	case 8:
+		return *const_cast<numeric *>(_num8_p);
+	case 9:
+		return *const_cast<numeric *>(_num9_p);
+	case 10:
+		return *const_cast<numeric *>(_num10_p);
+	case 11:
+		return *const_cast<numeric *>(_num11_p);
+	case 12:
+		return *const_cast<numeric *>(_num12_p);
+	default:
+		basic *bp = new numeric(i);
+		bp->setflag(status_flags::dynallocated);
+		GINAC_ASSERT(bp->get_refcount() == 0);
+		return *bp;
+	}
+}
+	
+basic & ex::construct_from_ulong(unsigned long i)
+{
+	switch (i) {  // prefer flyweights over new objects
+	case 0:
+		return *const_cast<numeric *>(_num0_p);
+	case 1:
+		return *const_cast<numeric *>(_num1_p);
+	case 2:
+		return *const_cast<numeric *>(_num2_p);
+	case 3:
+		return *const_cast<numeric *>(_num3_p);
+	case 4:
+		return *const_cast<numeric *>(_num4_p);
+	case 5:
+		return *const_cast<numeric *>(_num5_p);
+	case 6:
+		return *const_cast<numeric *>(_num6_p);
+	case 7:
+		return *const_cast<numeric *>(_num7_p);
+	case 8:
+		return *const_cast<numeric *>(_num8_p);
+	case 9:
+		return *const_cast<numeric *>(_num9_p);
+	case 10:
+		return *const_cast<numeric *>(_num10_p);
+	case 11:
+		return *const_cast<numeric *>(_num11_p);
+	case 12:
+		return *const_cast<numeric *>(_num12_p);
+	default:
+		basic *bp = new numeric(i);
+		bp->setflag(status_flags::dynallocated);
+		GINAC_ASSERT(bp->get_refcount() == 0);
+		return *bp;
+	}
+}
+	
+basic & ex::construct_from_double(double d)
+{
+	basic *bp = new numeric(d);
+	bp->setflag(status_flags::dynallocated);
+	GINAC_ASSERT(bp->get_refcount() == 0);
+	return *bp;
+}
+
+ptr<basic> ex::construct_from_string_and_lst(const std::string &s, const ex &l)
+{
+	set_lexer_string(s);
+	set_lexer_symbols(l);
+	ginac_yyrestart(NULL);
+	if (ginac_yyparse())
+		throw (std::runtime_error(get_parser_error()));
+	else
+		return parsed_ex.bp;
+}
+	
 //////////
 // static member variables
 //////////
@@ -463,45 +582,7 @@ 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;
-}
 
+} // namespace GiNaC