* Implementation of GiNaC's light-weight expression handles. */
/*
- * GiNaC Copyright (C) 1999-2000 Johannes Gutenberg University Mainz, Germany
+ * GiNaC Copyright (C) 1999-2011 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
*
* 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 <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 "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;
-}
+#include <iostream>
+#include <stdexcept>
-#endif // ndef INLINE_EX_CONSTRUCTORS
+namespace GiNaC {
//////////
// 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 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)
-{
- 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(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
+
+/** 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 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";
+ 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
+void ex::dbgprinttree() const
{
- debugmsg("ex dbgprinttree",LOGLEVEL_PRINT);
- GINAC_ASSERT(bp!=0);
- bp->dbgprinttree();
-}
-
-bool ex::info(unsigned inf) 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);
+ 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(const ex & 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
{
- GINAC_ASSERT(bp!=0);
- return bp->has(other);
+ if (!nth)
+ return *this;
+ else
+ return bp->diff(s, nth);
}
-int ex::degree(const symbol & s) const
+/** Check whether expression matches a specified pattern. */
+bool ex::match(const ex & pattern) const
{
- GINAC_ASSERT(bp!=0);
- return bp->degree(s);
+ exmap repl_lst;
+ return bp->match(pattern, repl_lst);
}
-int ex::ldegree(const symbol & 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, exset& found) const
{
- GINAC_ASSERT(bp!=0);
- return bp->ldegree(s);
+ if (match(pattern)) {
+ found.insert(*this);
+ 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(const symbol & s, int 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
{
- GINAC_ASSERT(bp!=0);
- return bp->coeff(s,n);
-}
+ GINAC_ASSERT(ls.nops() == lr.nops());
-ex ex::collect(const symbol & s) const
-{
- GINAC_ASSERT(bp!=0);
- return bp->collect(s);
-}
+ // 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::eval(int level) const
-{
- GINAC_ASSERT(bp!=0);
- return bp->eval(level);
-}
+ // 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::evalf(int level) const
-{
- GINAC_ASSERT(bp!=0);
- return bp->evalf(level);
+ return bp->subs(m, options);
}
-/** 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
+/** 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
{
- GINAC_ASSERT(bp!=0);
+ if (e.info(info_flags::relation_equal)) {
- if (!nth)
- return *this;
- else
- return bp->diff(s, nth);
-}
+ // 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(const lst & ls, const lst & lr) const
-{
- GINAC_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(const ex & e) const
-{
- GINAC_ASSERT(bp!=0);
- return bp->subs(e);
-}
+ return bp->subs(m, options);
-exvector ex::get_indices(void) const
-{
- GINAC_ASSERT(bp!=0);
- return bp->get_indices();
-}
+ } else if (e.info(info_flags::list)) {
-ex ex::simplify_ncmul(const exvector & v) const
-{
- GINAC_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[](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<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 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
-{
- debugmsg("ex op()",LOGLEVEL_MEMBER_FUNCTION);
- GINAC_ASSERT(bp!=0);
- return bp->op(i);
+ } else
+ throw(std::invalid_argument("ex::subs(ex): argument must be a relation_equal or a list"));
}
-/** Return modifyable operand/member at position i. */
-ex & ex::let_op(int i)
+/** Traverse expression tree with given visitor, preorder traversal. */
+void ex::traverse_preorder(visitor & v) const
{
- debugmsg("ex let_op()",LOGLEVEL_MEMBER_FUNCTION);
- makewriteable();
- GINAC_ASSERT(bp!=0);
- return bp->let_op(i);
-}
+ accept(v);
-/** 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<relational *>(bp)).lhs();
+ size_t n = nops();
+ for (size_t i = 0; i < n; ++i)
+ op(i).traverse_preorder(v);
}
-/** Right hand side of relational expression. */
-ex ex::rhs(void) const
+/** Traverse expression tree with given visitor, postorder traversal. */
+void ex::traverse_postorder(visitor & v) const
{
- debugmsg("ex rhs()",LOGLEVEL_MEMBER_FUNCTION);
- GINAC_ASSERT(is_ex_of_type(*this,relational));
- return (*static_cast<relational *>(bp)).rhs();
-}
+ size_t n = nops();
+ for (size_t i = 0; i < n; ++i)
+ op(i).traverse_postorder(v);
-#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);
+ accept(v);
}
-#endif // ndef INLINE_EX_CONSTRUCTORS
-#ifndef INLINE_EX_CONSTRUCTORS
-bool ex::is_equal(const ex & other) const
+/** Return modifyable operand/member at position i. */
+ex & ex::let_op(size_t i)
{
- 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);
+ makewriteable();
+ return bp->let_op(i);
}
-#endif // ndef INLINE_EX_CONSTRUCTORS
-unsigned ex::return_type(void) const
+ex & ex::operator[](const ex & index)
{
- GINAC_ASSERT(bp!=0);
- return bp->return_type();
+ makewriteable();
+ return (*bp)[index];
}
-unsigned ex::return_type_tinfo(void) const
+ex & ex::operator[](size_t i)
{
- GINAC_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
{
- GINAC_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(const ex & 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(const ex & 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(const ex & 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);
- 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);
+ 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;
}
-void ex::construct_from_basic(const basic & other)
-{
- 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<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);
-}
-
-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);
-}
-
-void ex::construct_from_string_and_lst(const 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
//////////
// none
-#ifndef NO_NAMESPACE_GINAC
} // namespace GiNaC
-#endif // ndef NO_NAMESPACE_GINAC
git://www.ginac.de / ginac.git / blobdiff