* Implementation of GiNaC's light-weight expression handles. */
/*
- * GiNaC Copyright (C) 1999 Johannes Gutenberg University Mainz, Germany
+ * GiNaC Copyright (C) 1999-2002 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
*/
#include <iostream>
+#include <stdexcept>
#include "ex.h"
#include "add.h"
#include "ncmul.h"
#include "numeric.h"
#include "power.h"
-#include "debugmsg.h"
+#include "lst.h"
+#include "relational.h"
+#include "input_lexer.h"
+#include "utils.h"
-#ifndef NO_GINAC_NAMESPACE
namespace GiNaC {
-#endif // ndef NO_GINAC_NAMESPACE
//////////
-// default constructor, destructor, copy constructor assignment operator and helpers
+// other ctors
//////////
-// public
-
-#ifndef INLINE_EX_CONSTRUCTORS
-
-ex::ex() : bp(exZERO().bp)
-{
- debugmsg("ex default constructor",LOGLEVEL_CONSTRUCT);
- GINAC_ASSERT(exZERO().bp!=0);
- GINAC_ASSERT(exZERO().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(ex const & other) : bp(other.bp)
-{
- debugmsg("ex copy constructor",LOGLEVEL_CONSTRUCT);
- GINAC_ASSERT(bp!=0);
- GINAC_ASSERT((bp->flags) & status_flags::dynallocated);
- ++bp->refcount;
-}
-
-ex const & ex::operator=(ex const & 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(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)
-{
- 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;
-}
-
-bool ex::info(unsigned inf) 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);
- }
-}
-
-int ex::nops() const
-{
- GINAC_ASSERT(bp!=0);
- return bp->nops();
-}
-
-ex ex::expand(unsigned options) const
-{
- GINAC_ASSERT(bp!=0);
- return bp->expand(options);
-}
-
-bool ex::has(ex const & other) const
+
+/** 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
{
- GINAC_ASSERT(bp!=0);
- return bp->has(other);
+ GINAC_ASSERT(bp!=0);
+ bp->print(c, level);
}
-int ex::degree(symbol const & s) const
+/** Print expression to stream in a tree-like format suitable for debugging. */
+void ex::printtree(std::ostream & os) const
{
- GINAC_ASSERT(bp!=0);
- return bp->degree(s);
+ GINAC_ASSERT(bp!=0);
+ bp->print(print_tree(os));
}
-int ex::ldegree(symbol const & s) const
+/** Little wrapper arount print to be called within a debugger. */
+void ex::dbgprint(void) const
{
- GINAC_ASSERT(bp!=0);
- return bp->ldegree(s);
+ GINAC_ASSERT(bp!=0);
+ bp->dbgprint();
}
-ex ex::coeff(symbol const & s, int const n) const
+/** Little wrapper arount printtree to be called within a debugger. */
+void ex::dbgprinttree(void) const
{
- GINAC_ASSERT(bp!=0);
- return bp->coeff(s,n);
+ GINAC_ASSERT(bp!=0);
+ bp->dbgprinttree();
}
-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;
-}
-
-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;
-}
-
-ex ex::collect(symbol const & 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);
-}
-
-ex ex::subs(lst const & ls, lst const & lr) const
-{
- GINAC_ASSERT(bp!=0);
- return bp->subs(ls,lr);
-}
-
-ex ex::subs(ex const & e) const
-{
- GINAC_ASSERT(bp!=0);
- return bp->subs(e);
-}
-
-exvector ex::get_indices(void) const
-{
- GINAC_ASSERT(bp!=0);
- return bp->get_indices();
-}
-
-ex ex::simplify_ncmul(exvector const & v) const
-{
- GINAC_ASSERT(bp!=0);
- return bp->simplify_ncmul(v);
-}
-
-ex ex::operator[](ex const & index) const
-{
- debugmsg("ex operator[ex]",LOGLEVEL_OPERATOR);
- GINAC_ASSERT(bp!=0);
- return (*bp)[index];
-}
-
-ex ex::operator[](int const i) const
-{
- debugmsg("ex operator[int]",LOGLEVEL_OPERATOR);
- GINAC_ASSERT(bp!=0);
- return (*bp)[i];
-}
-
-ex ex::op(int const i) const
+ex ex::expand(unsigned options) const
{
- debugmsg("ex op()",LOGLEVEL_MEMBER_FUNCTION);
- GINAC_ASSERT(bp!=0);
- return bp->op(i);
+ GINAC_ASSERT(bp!=0);
+ 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 *bp;
+ else
+ return bp->expand(options);
}
-ex & ex::let_op(int const i)
+/** 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
{
- debugmsg("ex let_op()",LOGLEVEL_MEMBER_FUNCTION);
- makewriteable();
- GINAC_ASSERT(bp!=0);
- return bp->let_op(i);
-}
+ GINAC_ASSERT(bp!=0);
-#ifndef INLINE_EX_CONSTRUCTORS
-int ex::compare(ex const & 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);
+ if (!nth)
+ return *this;
+ else
+ return bp->diff(s, nth);
}
-#endif // ndef INLINE_EX_CONSTRUCTORS
-#ifndef INLINE_EX_CONSTRUCTORS
-bool ex::is_equal(ex const & other) const
+/** Check whether expression matches a specified pattern. */
+bool ex::match(const ex & pattern) 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 true;
- }
- return bp->is_equal(*other.bp);
+ lst repl_lst;
+ return bp->match(pattern, repl_lst);
}
-#endif // ndef INLINE_EX_CONSTRUCTORS
-unsigned ex::return_type(void) 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->return_type();
+ if (match(pattern)) {
+ found.append(*this);
+ found.sort();
+ found.unique();
+ return true;
+ }
+ bool any_found = false;
+ for (unsigned i=0; i<nops(); i++)
+ if (op(i).find(pattern, found))
+ any_found = true;
+ return any_found;
}
-unsigned ex::return_type_tinfo(void) const
+ex ex::operator[](const ex & index) const
{
- GINAC_ASSERT(bp!=0);
- return bp->return_type_tinfo();
+ GINAC_ASSERT(bp!=0);
+ return (*bp)[index];
}
-unsigned ex::gethash(void) const
+ex ex::operator[](int i) const
{
- GINAC_ASSERT(bp!=0);
- return bp->gethash();
+ GINAC_ASSERT(bp!=0);
+ return (*bp)[i];
}
-ex ex::exadd(ex const & rh) const
+/** Return modifyable operand/member at position i. */
+ex & ex::let_op(int i)
{
- return (new add(*this,rh))->setflag(status_flags::dynallocated);
+ makewriteable();
+ GINAC_ASSERT(bp!=0);
+ return bp->let_op(i);
}
-ex ex::exmul(ex const & rh) const
+/** Left hand side of relational expression. */
+ex ex::lhs(void) const
{
- return (new mul(*this,rh))->setflag(status_flags::dynallocated);
+ if (!is_ex_of_type(*this,relational))
+ throw std::runtime_error("ex::lhs(): not a relation");
+ return (*static_cast<relational *>(bp)).lhs();
}
-ex ex::exncmul(ex const & rh) const
+/** Right hand side of relational expression. */
+ex ex::rhs(void) const
{
- return (new ncmul(*this,rh))->setflag(status_flags::dynallocated);
+ if (!is_ex_of_type(*this,relational))
+ throw std::runtime_error("ex::rhs(): not a relation");
+ return (*static_cast<relational *>(bp)).rhs();
}
// 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);
- 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);
-}
-
-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;
- 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);
- } else {
- 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);
-}
-
+ 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);
+}
+
+/** Ctor from basic implementation.
+ * @see ex::ex(const basic &) */
+void ex::construct_from_basic(const basic & other)
+{
+ if (!(other.flags & status_flags::evaluated)) {
+ const ex & tmpex = other.eval(1); // evaluate only one (top) level
+ bp = tmpex.bp;
+ GINAC_ASSERT(bp->flags & status_flags::dynallocated);
+ ++bp->refcount;
+ if ((other.refcount==0) && (other.flags & status_flags::dynallocated))
+ delete &const_cast<basic &>(other);
+ } else {
+ if (other.flags & status_flags::dynallocated) {
+ // ok, it is already on the heap, so just copy bp:
+ bp = &const_cast<basic &>(other);
+ } else {
+ // create a duplicate on the heap:
+ bp = other.duplicate();
+ bp->setflag(status_flags::dynallocated);
+ }
+ GINAC_ASSERT(bp!=0);
+ ++bp->refcount;
+ }
+ GINAC_ASSERT(bp!=0);
+ GINAC_ASSERT(bp->flags & status_flags::dynallocated);
+}
+
+void ex::construct_from_int(int i)
+{
+ switch (i) { // prefer flyweights over new objects
+ case -12:
+ bp = (basic*)_num_12_p;
+ ++bp->refcount;
+ break;
+ case -11:
+ bp = (basic*)_num_11_p;
+ ++bp->refcount;
+ break;
+ case -10:
+ bp = (basic*)_num_10_p;
+ ++bp->refcount;
+ break;
+ case -9:
+ bp = (basic*)_num_9_p;
+ ++bp->refcount;
+ break;
+ case -8:
+ bp = (basic*)_num_8_p;
+ ++bp->refcount;
+ break;
+ case -7:
+ bp = (basic*)_num_7_p;
+ ++bp->refcount;
+ break;
+ case -6:
+ bp = (basic*)_num_6_p;
+ ++bp->refcount;
+ break;
+ case -5:
+ bp = (basic*)_num_5_p;
+ ++bp->refcount;
+ break;
+ case -4:
+ bp = (basic*)_num_4_p;
+ ++bp->refcount;
+ break;
+ case -3:
+ bp = (basic*)_num_3_p;
+ ++bp->refcount;
+ break;
+ case -2:
+ bp = (basic*)_num_2_p;
+ ++bp->refcount;
+ break;
+ case -1:
+ bp = (basic*)_num_1_p;
+ ++bp->refcount;
+ break;
+ case 0:
+ bp = (basic*)_num0_p;
+ ++bp->refcount;
+ break;
+ case 1:
+ bp = (basic*)_num1_p;
+ ++bp->refcount;
+ break;
+ case 2:
+ bp = (basic*)_num2_p;
+ ++bp->refcount;
+ break;
+ case 3:
+ bp = (basic*)_num3_p;
+ ++bp->refcount;
+ break;
+ case 4:
+ bp = (basic*)_num4_p;
+ ++bp->refcount;
+ break;
+ case 5:
+ bp = (basic*)_num5_p;
+ ++bp->refcount;
+ break;
+ case 6:
+ bp = (basic*)_num6_p;
+ ++bp->refcount;
+ break;
+ case 7:
+ bp = (basic*)_num7_p;
+ ++bp->refcount;
+ break;
+ case 8:
+ bp = (basic*)_num8_p;
+ ++bp->refcount;
+ break;
+ case 9:
+ bp = (basic*)_num9_p;
+ ++bp->refcount;
+ break;
+ case 10:
+ bp = (basic*)_num10_p;
+ ++bp->refcount;
+ break;
+ case 11:
+ bp = (basic*)_num11_p;
+ ++bp->refcount;
+ break;
+ case 12:
+ bp = (basic*)_num12_p;
+ ++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) { // prefer flyweights over new objects
+ case 0:
+ bp = (basic*)_num0_p;
+ ++bp->refcount;
+ break;
+ case 1:
+ bp = (basic*)_num1_p;
+ ++bp->refcount;
+ break;
+ case 2:
+ bp = (basic*)_num2_p;
+ ++bp->refcount;
+ break;
+ case 3:
+ bp = (basic*)_num3_p;
+ ++bp->refcount;
+ break;
+ case 4:
+ bp = (basic*)_num4_p;
+ ++bp->refcount;
+ break;
+ case 5:
+ bp = (basic*)_num5_p;
+ ++bp->refcount;
+ break;
+ case 6:
+ bp = (basic*)_num6_p;
+ ++bp->refcount;
+ break;
+ case 7:
+ bp = (basic*)_num7_p;
+ ++bp->refcount;
+ break;
+ case 8:
+ bp = (basic*)_num8_p;
+ ++bp->refcount;
+ break;
+ case 9:
+ bp = (basic*)_num9_p;
+ ++bp->refcount;
+ break;
+ case 10:
+ bp = (basic*)_num10_p;
+ ++bp->refcount;
+ break;
+ case 11:
+ bp = (basic*)_num11_p;
+ ++bp->refcount;
+ break;
+ case 12:
+ bp = (basic*)_num12_p;
+ ++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) { // prefer flyweights over new objects
+ case -12:
+ bp = (basic*)_num_12_p;
+ ++bp->refcount;
+ break;
+ case -11:
+ bp = (basic*)_num_11_p;
+ ++bp->refcount;
+ break;
+ case -10:
+ bp = (basic*)_num_10_p;
+ ++bp->refcount;
+ break;
+ case -9:
+ bp = (basic*)_num_9_p;
+ ++bp->refcount;
+ break;
+ case -8:
+ bp = (basic*)_num_8_p;
+ ++bp->refcount;
+ break;
+ case -7:
+ bp = (basic*)_num_7_p;
+ ++bp->refcount;
+ break;
+ case -6:
+ bp = (basic*)_num_6_p;
+ ++bp->refcount;
+ break;
+ case -5:
+ bp = (basic*)_num_5_p;
+ ++bp->refcount;
+ break;
+ case -4:
+ bp = (basic*)_num_4_p;
+ ++bp->refcount;
+ break;
+ case -3:
+ bp = (basic*)_num_3_p;
+ ++bp->refcount;
+ break;
+ case -2:
+ bp = (basic*)_num_2_p;
+ ++bp->refcount;
+ break;
+ case -1:
+ bp = (basic*)_num_1_p;
+ ++bp->refcount;
+ break;
+ case 0:
+ bp = (basic*)_num0_p;
+ ++bp->refcount;
+ break;
+ case 1:
+ bp = (basic*)_num1_p;
+ ++bp->refcount;
+ break;
+ case 2:
+ bp = (basic*)_num2_p;
+ ++bp->refcount;
+ break;
+ case 3:
+ bp = (basic*)_num3_p;
+ ++bp->refcount;
+ break;
+ case 4:
+ bp = (basic*)_num4_p;
+ ++bp->refcount;
+ break;
+ case 5:
+ bp = (basic*)_num5_p;
+ ++bp->refcount;
+ break;
+ case 6:
+ bp = (basic*)_num6_p;
+ ++bp->refcount;
+ break;
+ case 7:
+ bp = (basic*)_num7_p;
+ ++bp->refcount;
+ break;
+ case 8:
+ bp = (basic*)_num8_p;
+ ++bp->refcount;
+ break;
+ case 9:
+ bp = (basic*)_num9_p;
+ ++bp->refcount;
+ break;
+ case 10:
+ bp = (basic*)_num10_p;
+ ++bp->refcount;
+ break;
+ case 11:
+ bp = (basic*)_num11_p;
+ ++bp->refcount;
+ break;
+ case 12:
+ bp = (basic*)_num12_p;
+ ++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) { // prefer flyweights over new objects
+ case 0:
+ bp = (basic*)_num0_p;
+ ++bp->refcount;
+ break;
+ case 1:
+ bp = (basic*)_num1_p;
+ ++bp->refcount;
+ break;
+ case 2:
+ bp = (basic*)_num2_p;
+ ++bp->refcount;
+ break;
+ case 3:
+ bp = (basic*)_num3_p;
+ ++bp->refcount;
+ break;
+ case 4:
+ bp = (basic*)_num4_p;
+ ++bp->refcount;
+ break;
+ case 5:
+ bp = (basic*)_num5_p;
+ ++bp->refcount;
+ break;
+ case 6:
+ bp = (basic*)_num6_p;
+ ++bp->refcount;
+ break;
+ case 7:
+ bp = (basic*)_num7_p;
+ ++bp->refcount;
+ break;
+ case 8:
+ bp = (basic*)_num8_p;
+ ++bp->refcount;
+ break;
+ case 9:
+ bp = (basic*)_num9_p;
+ ++bp->refcount;
+ break;
+ case 10:
+ bp = (basic*)_num10_p;
+ ++bp->refcount;
+ break;
+ case 11:
+ bp = (basic*)_num11_p;
+ ++bp->refcount;
+ break;
+ case 12:
+ bp = (basic*)_num12_p;
+ ++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);
+}
+
+void 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 {
+ bp = parsed_ex.bp;
+ GINAC_ASSERT(bp!=0);
+ GINAC_ASSERT((bp->flags) & status_flags::dynallocated);
+ ++bp->refcount;
+ }
+}
+
//////////
// static member variables
//////////
// 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_GINAC_NAMESPACE
} // namespace GiNaC
-#endif // ndef NO_GINAC_NAMESPACE
git://www.ginac.de / ginac.git / blobdiff