X-Git-Url: https://www.ginac.de/ginac.git//ginac.git?p=ginac.git;a=blobdiff_plain;f=ginac%2Fex.cpp;h=a5ede054b13eeb35ebb3b50fc90d4b3166a04a94;hp=2857cdc846ab4ff78010791905b4b1929c83bbfb;hb=270969d036bd27a8454442501f8eb241fa66c9b2;hpb=bd2d7351b89743eb68ce7d3bfa7ab62c331f9522 diff --git a/ginac/ex.cpp b/ginac/ex.cpp index 2857cdc8..a5ede054 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-2000 Johannes Gutenberg University Mainz, Germany + * GiNaC Copyright (C) 1999-2005 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 @@ -17,7 +17,7 @@ * * 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 @@ -29,281 +29,53 @@ #include "ncmul.h" #include "numeric.h" #include "power.h" +#include "lst.h" #include "relational.h" #include "input_lexer.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 -////////// - -// public - -#ifndef INLINE_EX_CONSTRUCTORS - -ex::ex() : bp(_ex0().bp) -{ - debugmsg("ex default constructor",LOGLEVEL_CONSTRUCT); - 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); - GINAC_ASSERT(bp!=0); - GINAC_ASSERT(bp->flags & status_flags::dynallocated); - if (--bp->refcount == 0) { - delete bp; - } -} - -ex::ex(const ex & other) : bp(other.bp) -{ - debugmsg("ex copy constructor",LOGLEVEL_CONSTRUCT); - GINAC_ASSERT(bp!=0); - GINAC_ASSERT((bp->flags) & status_flags::dynallocated); - ++bp->refcount; -} - -const ex & ex::operator=(const ex & other) -{ - debugmsg("ex operator=",LOGLEVEL_ASSIGNMENT); - 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) { - delete bp; - } - bp=tmpbp; - return *this; -} - -#endif // ndef INLINE_EX_CONSTRUCTORS ////////// // other constructors ////////// -// public - -#ifndef INLINE_EX_CONSTRUCTORS - -ex::ex(const basic & other) -{ - debugmsg("ex constructor from basic",LOGLEVEL_CONSTRUCT); - construct_from_basic(other); -} - -ex::ex(int i) -{ - debugmsg("ex constructor from int",LOGLEVEL_CONSTRUCT); - construct_from_int(i); -} - -ex::ex(unsigned int i) -{ - debugmsg("ex constructor from unsigned int",LOGLEVEL_CONSTRUCT); - construct_from_uint(i); -} - -ex::ex(long i) -{ - debugmsg("ex constructor from long",LOGLEVEL_CONSTRUCT); - construct_from_long(i); -} - -ex::ex(unsigned long i) -{ - debugmsg("ex constructor from unsigned long",LOGLEVEL_CONSTRUCT); - construct_from_ulong(i); -} - -ex::ex(double const d) -{ - debugmsg("ex constructor from double",LOGLEVEL_CONSTRUCT); - construct_from_double(d); -} - -ex::ex(const std::string &s, const ex &l) -{ - debugmsg("ex constructor from string,lst",LOGLEVEL_CONSTRUCT); - construct_from_string_and_lst(s, l); -} - -#endif // ndef INLINE_EX_CONSTRUCTORS - -////////// -// 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 - -/** Swap the contents of two expressions. */ -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); - - 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(std::ostream & os, unsigned upper_precedence) const -{ - debugmsg("ex print",LOGLEVEL_PRINT); - GINAC_ASSERT(bp!=0); - bp->print(os,upper_precedence); -} - -void ex::printraw(std::ostream & os) const -{ - debugmsg("ex printraw",LOGLEVEL_PRINT); - GINAC_ASSERT(bp!=0); - os << "ex("; - bp->printraw(os); - os << ")"; -} - -void ex::printtree(std::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 - * " = ;". 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(std::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"; + bp->print(c, level); } /** Little wrapper arount print to be called within a debugger. */ -void ex::dbgprint(void) const +void ex::dbgprint() const { - debugmsg("ex dbgprint",LOGLEVEL_PRINT); - GINAC_ASSERT(bp!=0); - bp->dbgprint(); + 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 +void ex::dbgprinttree() const { - return bp->info(inf); -} - -unsigned ex::nops() const -{ - GINAC_ASSERT(bp!=0); - return bp->nops(); + bp->dbgprinttree(); } ex ex::expand(unsigned options) const { - GINAC_ASSERT(bp!=0); - if (bp->flags & status_flags::expanded) - return *bp; - else - return bp->expand(options); -} - -bool ex::has(const ex & other) const -{ - GINAC_ASSERT(bp!=0); - return bp->has(other); -} - -int ex::degree(const symbol & s) const -{ - GINAC_ASSERT(bp!=0); - return bp->degree(s); -} - -int ex::ldegree(const symbol & s) const -{ - GINAC_ASSERT(bp!=0); - return bp->ldegree(s); -} - -ex ex::coeff(const symbol & s, int n) const -{ - GINAC_ASSERT(bp!=0); - return bp->coeff(s,n); -} - -ex ex::collect(const symbol & s) const -{ - GINAC_ASSERT(bp!=0); - return bp->collect(s); -} - -ex ex::eval(int level) const -{ - GINAC_ASSERT(bp!=0); - return bp->eval(level); -} - -ex ex::evalf(int level) const -{ - GINAC_ASSERT(bp!=0); - return bp->evalf(level); + 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); } /** Compute partial derivative of an expression. @@ -313,342 +85,461 @@ ex ex::evalf(int level) const * @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); + if (!nth) + return *this; + else + return bp->diff(s, nth); } -ex ex::subs(const lst & ls, const lst & lr) const +/** Check whether expression matches a specified pattern. */ +bool ex::match(const ex & pattern) const { - GINAC_ASSERT(bp!=0); - return bp->subs(ls,lr); + lst repl_lst; + return bp->match(pattern, repl_lst); } -ex ex::subs(const ex & e) 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 { - GINAC_ASSERT(bp!=0); - return bp->subs(e); + if (match(pattern)) { + found.append(*this); + found.sort(); + found.unique(); + return true; + } + bool any_found = false; + for (size_t i=0; iget_indices(); -} + GINAC_ASSERT(ls.nops() == lr.nops()); -ex ex::simplify_ncmul(const exvector & v) const -{ - GINAC_ASSERT(bp!=0); - return bp->simplify_ncmul(v); -} + // 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::operator[](const ex & index) const -{ - debugmsg("ex operator[ex]",LOGLEVEL_OPERATOR); - GINAC_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(*its) || is_exactly_a(*its)) + options |= subs_options::pattern_is_product; + } + if (!(options & subs_options::pattern_is_product)) + options |= subs_options::pattern_is_not_product; -ex ex::operator[](int i) const -{ - debugmsg("ex operator[int]",LOGLEVEL_OPERATOR); - GINAC_ASSERT(bp!=0); - return (*bp)[i]; + return bp->subs(m, options); } -/** Return operand/member at position i. */ -ex ex::op(int i) 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 { - debugmsg("ex op()",LOGLEVEL_MEMBER_FUNCTION); - GINAC_ASSERT(bp!=0); - return bp->op(i); -} + if (e.info(info_flags::relation_equal)) { -/** Return modifyable operand/member at position i. */ -ex & ex::let_op(int i) -{ - debugmsg("ex let_op()",LOGLEVEL_MEMBER_FUNCTION); - makewriteable(); - GINAC_ASSERT(bp!=0); - return bp->let_op(i); -} + // 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))); -/** Left hand side of relational expression. */ -ex ex::lhs(void) const -{ - debugmsg("ex lhs()",LOGLEVEL_MEMBER_FUNCTION); - GINAC_ASSERT(is_ex_of_type(*this,relational)); - return (*static_cast(bp)).lhs(); -} + if (is_exactly_a(s) || is_exactly_a(s)) + options |= subs_options::pattern_is_product; + else + options |= subs_options::pattern_is_not_product; -/** Right hand side of relational expression. */ -ex ex::rhs(void) const -{ - debugmsg("ex rhs()",LOGLEVEL_MEMBER_FUNCTION); - GINAC_ASSERT(is_ex_of_type(*this,relational)); - return (*static_cast(bp)).rhs(); -} + return bp->subs(m, options); -#ifndef INLINE_EX_CONSTRUCTORS -int ex::compare(const ex & other) const -{ - 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; - } - return bp->compare(*other.bp); -} -#endif // ndef INLINE_EX_CONSTRUCTORS + } else if (e.info(info_flags::list)) { -#ifndef INLINE_EX_CONSTRUCTORS -bool ex::is_equal(const ex & other) const -{ - GINAC_ASSERT(bp!=0); - GINAC_ASSERT(other.bp!=0); - // if both expression point to same basic they are trivially equal - if (bp==other.bp) - return true; - - return bp->is_equal(*other.bp); -} -#endif // ndef INLINE_EX_CONSTRUCTORS + // Argument is a list: convert it to a map + exmap m; + GINAC_ASSERT(is_a(e)); + for (lst::const_iterator it = ex_to(e).begin(); it != ex_to(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))); -unsigned ex::return_type(void) const -{ - GINAC_ASSERT(bp!=0); - return bp->return_type(); -} + // Search for products and powers in the expressions to be substituted + // (for an optimization in expairseq::subs()) + if (is_exactly_a(s) || is_exactly_a(s)) + options |= subs_options::pattern_is_product; + } + if (!(options & subs_options::pattern_is_product)) + options |= subs_options::pattern_is_not_product; -unsigned ex::return_type_tinfo(void) const -{ - GINAC_ASSERT(bp!=0); - return bp->return_type_tinfo(); -} + return bp->subs(m, options); -unsigned ex::gethash(void) const -{ - GINAC_ASSERT(bp!=0); - return bp->gethash(); + } else + throw(std::invalid_argument("ex::subs(ex): argument must be a relation_equal or a list")); } -ex ex::exadd(const ex & rh) const +/** Traverse expression tree with given visitor, preorder traversal. */ +void ex::traverse_preorder(visitor & v) const { - return (new add(*this,rh))->setflag(status_flags::dynallocated); -} + accept(v); -ex ex::exmul(const ex & rh) const -{ - return (new mul(*this,rh))->setflag(status_flags::dynallocated); + size_t n = nops(); + for (size_t i = 0; i < n; ++i) + op(i).traverse_preorder(v); } -ex ex::exncmul(const ex & rh) const +/** Traverse expression tree with given visitor, postorder traversal. */ +void ex::traverse_postorder(visitor & v) const { - return (new ncmul(*this,rh))->setflag(status_flags::dynallocated); -} - -// private + size_t n = nops(); + for (size_t i = 0; i < n; ++i) + op(i).traverse_postorder(v); -void ex::makewriteable() -{ - debugmsg("ex makewriteable",LOGLEVEL_MEMBER_FUNCTION); - GINAC_ASSERT(bp!=0); - GINAC_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; - } - GINAC_ASSERT(bp->refcount == 1); + accept(v); } -void ex::construct_from_basic(const basic & other) +/** Return modifyable operand/member at position i. */ +ex & ex::let_op(size_t i) { - if ((other.flags & status_flags::evaluated)==0) { - // cf. copy constructor - const ex & tmpex = other.eval(1); // evaluate only one (top) level - bp = tmpex.bp; - 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(other); - } - } else { - if (other.flags & status_flags::dynallocated) { - // it's on the heap, so just copy bp: - bp = &const_cast(other); - } else { - // create a duplicate on the heap: - bp = other.duplicate(); - bp->setflag(status_flags::dynallocated); - } - GINAC_ASSERT(bp!=0); - // bp->clearflag(status_flags::evaluated); - ++bp->refcount; - } - GINAC_ASSERT(bp!=0); - GINAC_ASSERT(bp->flags & status_flags::dynallocated); + makewriteable(); + return bp->let_op(i); } -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) +ex & ex::operator[](const ex & index) { - 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); - } + makewriteable(); + return (*bp)[index]; } - -void ex::construct_from_long(long i) + +ex & ex::operator[](size_t 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); - } + makewriteable(); + return (*bp)[i]; } - -void ex::construct_from_ulong(unsigned long i) + +/** Left hand side of relational expression. */ +ex ex::lhs() const { - 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); - } + if (!is_a(*this)) + throw std::runtime_error("ex::lhs(): not a relation"); + return bp->op(0); } - -void ex::construct_from_double(double d) + +/** Right hand side of relational expression. */ +ex ex::rhs() const { - bp = new numeric(d); - bp->setflag(status_flags::dynallocated); - ++bp->refcount; - GINAC_ASSERT((bp->flags) & status_flags::dynallocated); - GINAC_ASSERT(bp->refcount=1); + if (!is_a(*this)) + throw std::runtime_error("ex::rhs(): not a relation"); + return bp->op(1); } -void ex::construct_from_string_and_lst(const std::string &s, const ex &l) +// 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() { - set_lexer_string(s); - set_lexer_symbols(l); - ginac_yyrestart(NULL); - if (ginac_yyparse()) - throw (std::runtime_error(get_parser_error())); - else { - bp = parsed_ex.bp; - GINAC_ASSERT(bp!=0); - GINAC_ASSERT((bp->flags) & status_flags::dynallocated); - ++bp->refcount; - } -} - + 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 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(const_cast(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(_num_12_p); + case -11: + return *const_cast(_num_11_p); + case -10: + return *const_cast(_num_10_p); + case -9: + return *const_cast(_num_9_p); + case -8: + return *const_cast(_num_8_p); + case -7: + return *const_cast(_num_7_p); + case -6: + return *const_cast(_num_6_p); + case -5: + return *const_cast(_num_5_p); + case -4: + return *const_cast(_num_4_p); + case -3: + return *const_cast(_num_3_p); + case -2: + return *const_cast(_num_2_p); + case -1: + return *const_cast(_num_1_p); + case 0: + return *const_cast(_num0_p); + case 1: + return *const_cast(_num1_p); + case 2: + return *const_cast(_num2_p); + case 3: + return *const_cast(_num3_p); + case 4: + return *const_cast(_num4_p); + case 5: + return *const_cast(_num5_p); + case 6: + return *const_cast(_num6_p); + case 7: + return *const_cast(_num7_p); + case 8: + return *const_cast(_num8_p); + case 9: + return *const_cast(_num9_p); + case 10: + return *const_cast(_num10_p); + case 11: + return *const_cast(_num11_p); + case 12: + return *const_cast(_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(_num0_p); + case 1: + return *const_cast(_num1_p); + case 2: + return *const_cast(_num2_p); + case 3: + return *const_cast(_num3_p); + case 4: + return *const_cast(_num4_p); + case 5: + return *const_cast(_num5_p); + case 6: + return *const_cast(_num6_p); + case 7: + return *const_cast(_num7_p); + case 8: + return *const_cast(_num8_p); + case 9: + return *const_cast(_num9_p); + case 10: + return *const_cast(_num10_p); + case 11: + return *const_cast(_num11_p); + case 12: + return *const_cast(_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(_num_12_p); + case -11: + return *const_cast(_num_11_p); + case -10: + return *const_cast(_num_10_p); + case -9: + return *const_cast(_num_9_p); + case -8: + return *const_cast(_num_8_p); + case -7: + return *const_cast(_num_7_p); + case -6: + return *const_cast(_num_6_p); + case -5: + return *const_cast(_num_5_p); + case -4: + return *const_cast(_num_4_p); + case -3: + return *const_cast(_num_3_p); + case -2: + return *const_cast(_num_2_p); + case -1: + return *const_cast(_num_1_p); + case 0: + return *const_cast(_num0_p); + case 1: + return *const_cast(_num1_p); + case 2: + return *const_cast(_num2_p); + case 3: + return *const_cast(_num3_p); + case 4: + return *const_cast(_num4_p); + case 5: + return *const_cast(_num5_p); + case 6: + return *const_cast(_num6_p); + case 7: + return *const_cast(_num7_p); + case 8: + return *const_cast(_num8_p); + case 9: + return *const_cast(_num9_p); + case 10: + return *const_cast(_num10_p); + case 11: + return *const_cast(_num11_p); + case 12: + return *const_cast(_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(_num0_p); + case 1: + return *const_cast(_num1_p); + case 2: + return *const_cast(_num2_p); + case 3: + return *const_cast(_num3_p); + case 4: + return *const_cast(_num4_p); + case 5: + return *const_cast(_num5_p); + case 6: + return *const_cast(_num6_p); + case 7: + return *const_cast(_num7_p); + case 8: + return *const_cast(_num8_p); + case 9: + return *const_cast(_num9_p); + case 10: + return *const_cast(_num10_p); + case 11: + return *const_cast(_num11_p); + case 12: + return *const_cast(_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 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 ////////// @@ -668,6 +559,4 @@ void ex::construct_from_string_and_lst(const std::string &s, const ex &l) // none -#ifndef NO_NAMESPACE_GINAC } // namespace GiNaC -#endif // ndef NO_NAMESPACE_GINAC