* Implementation of GiNaC's light-weight expression handles. */
/*
- * GiNaC Copyright (C) 1999-2001 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>
-#if defined(VERBOSE)
-# define GINAC_CONDITIONAL_INLINE
-# include "ex.h"
-# undef GINAC_CONDITIONAL_INLINE
-#else
-# include "ex.h"
-#endif
-
+#include "ex.h"
#include "add.h"
#include "mul.h"
#include "ncmul.h"
#include "numeric.h"
#include "power.h"
+#include "lst.h"
#include "relational.h"
-#include "indexed.h"
#include "input_lexer.h"
-#include "debugmsg.h"
#include "utils.h"
namespace GiNaC {
// none (all inlined)
-//////////
-// functions overriding virtual functions from bases classes
-//////////
-
-// none
-
-//////////
-// new virtual functions which can be overridden by derived classes
-//////////
-
-// none
-
//////////
// non-virtual functions in this class
//////////
// public
-
-/** Efficiently 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(std::ostream & os, unsigned upper_precedence) const
-{
- debugmsg("ex print",LOGLEVEL_PRINT);
- GINAC_ASSERT(bp!=0);
- bp->print(os,upper_precedence);
-}
-
-/** Unreadable output with detailed type information. */
-void ex::printraw(std::ostream & os) 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 printraw",LOGLEVEL_PRINT);
GINAC_ASSERT(bp!=0);
- os << "ex(";
- bp->printraw(os);
- os << ")";
+ bp->print(c, level);
}
-/** Very detailed and unreadable output with type information and all this. */
-void ex::printtree(std::ostream & os, unsigned indent) const
+/** Print expression to stream in a tree-like format suitable for debugging. */
+void ex::printtree(std::ostream & os) 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(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(print_tree(os));
}
/** Little wrapper arount print to be called within a debugger. */
void ex::dbgprint(void) const
{
- debugmsg("ex dbgprint",LOGLEVEL_PRINT);
GINAC_ASSERT(bp!=0);
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
-{
- return bp->info(inf);
-}
-
-unsigned ex::nops() const
-{
- GINAC_ASSERT(bp!=0);
- return bp->nops();
-}
-
ex ex::expand(unsigned options) const
{
GINAC_ASSERT(bp!=0);
- if (bp->flags & status_flags::expanded)
+ 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);
}
-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);
-}
-
/** Compute partial derivative of an expression.
*
* @param s symbol by which the expression is derived
return bp->diff(s, nth);
}
-ex ex::subs(const lst & ls, const lst & lr) const
-{
- GINAC_ASSERT(bp!=0);
- return bp->subs(ls,lr);
-}
-
-ex ex::subs(const ex & e) const
-{
- GINAC_ASSERT(bp!=0);
- return bp->subs(e);
-}
-
-/** Return a vector containing the free indices of the object. */
-exvector ex::get_free_indices(void) const
+/** Check whether expression matches a specified pattern. */
+bool ex::match(const ex & pattern) const
{
- GINAC_ASSERT(bp!=0);
- return bp->get_free_indices();
-}
-
-/** Simplify/canonicalize expression containing indexed objects. This
- * performs contraction of dummy indices where possible and checks whether
- * the free indices in sums are consistent.
- *
- * @return simplified expression */
-ex ex::simplify_indexed(void) const
-{
- return GiNaC::simplify_indexed(*this);
-}
-
-/** Simplify/canonicalize expression containing indexed objects. This
- * performs contraction of dummy indices where possible, checks whether
- * the free indices in sums are consistent, and automatically replaces
- * scalar products by known values if desired.
- *
- * @param sp Scalar products to be replaced automatically
- * @return simplified expression */
-ex ex::simplify_indexed(const scalar_products & sp) const
-{
- return GiNaC::simplify_indexed(*this, sp);
+ lst repl_lst;
+ return bp->match(pattern, repl_lst);
}
-ex ex::simplify_ncmul(const exvector & v) 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->simplify_ncmul(v);
+ 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;
}
ex ex::operator[](const ex & index) const
{
- debugmsg("ex operator[ex]",LOGLEVEL_OPERATOR);
GINAC_ASSERT(bp!=0);
return (*bp)[index];
}
ex ex::operator[](int i) const
{
- debugmsg("ex operator[int]",LOGLEVEL_OPERATOR);
GINAC_ASSERT(bp!=0);
return (*bp)[i];
}
-/** 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);
-}
-
/** 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);
/** 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));
+ if (!is_ex_of_type(*this,relational))
+ throw std::runtime_error("ex::lhs(): not a relation");
return (*static_cast<relational *>(bp)).lhs();
}
/** 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));
+ if (!is_ex_of_type(*this,relational))
+ throw std::runtime_error("ex::rhs(): not a relation");
return (*static_cast<relational *>(bp)).rhs();
}
-unsigned ex::return_type(void) const
-{
- GINAC_ASSERT(bp!=0);
- return bp->return_type();
-}
-
-unsigned ex::return_type_tinfo(void) const
-{
- GINAC_ASSERT(bp!=0);
- return bp->return_type_tinfo();
-}
-
-unsigned ex::gethash(void) const
-{
- GINAC_ASSERT(bp!=0);
- return bp->gethash();
-}
-
-/** Used internally by operator+() to add two ex objects together. */
-ex ex::exadd(const ex & rh) const
-{
- return (new add(*this,rh))->setflag(status_flags::dynallocated);
-}
-
-/** Used internally by operator*() to multiply two ex objects together. */
-ex ex::exmul(const ex & rh) const
-{
- // Check if we are constructing a mul object or a ncmul object. Due to
- // ncmul::eval()'s rule to pull out commutative elements we need to check
- // only one of the elements.
- if (rh.bp->return_type()==return_types::commutative ||
- bp->return_type()==return_types::commutative)
- return (new mul(*this,rh))->setflag(status_flags::dynallocated);
- else
- return (new ncmul(*this,rh))->setflag(status_flags::dynallocated);
-}
-
// 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) {
* @see ex::ex(const basic &) */
void ex::construct_from_basic(const basic & other)
{
- if ((other.flags & status_flags::evaluated)==0) {
- // cf. copy ctor
+ if (!(other.flags & status_flags::evaluated)) {
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))
+ if ((other.refcount==0) && (other.flags & status_flags::dynallocated))
delete &const_cast<basic &>(other);
} else {
if (other.flags & status_flags::dynallocated) {
bp->setflag(status_flags::dynallocated);
}
GINAC_ASSERT(bp!=0);
- // bp->clearflag(status_flags::evaluated);
++bp->refcount;
}
GINAC_ASSERT(bp!=0);
void ex::construct_from_int(int i)
{
- switch (i) { // some tiny efficiency-hack
+ 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 = _ex_2().bp;
+ bp = (basic*)_num_2_p;
++bp->refcount;
break;
case -1:
- bp = _ex_1().bp;
+ bp = (basic*)_num_1_p;
++bp->refcount;
break;
case 0:
- bp = _ex0().bp;
+ bp = (basic*)_num0_p;
++bp->refcount;
break;
case 1:
- bp = _ex1().bp;
+ bp = (basic*)_num1_p;
++bp->refcount;
break;
case 2:
- bp = _ex2().bp;
+ 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:
void ex::construct_from_uint(unsigned int i)
{
- switch (i) { // some tiny efficiency-hack
+ switch (i) { // prefer flyweights over new objects
case 0:
- bp = _ex0().bp;
+ bp = (basic*)_num0_p;
++bp->refcount;
break;
case 1:
- bp = _ex1().bp;
+ bp = (basic*)_num1_p;
++bp->refcount;
break;
case 2:
- bp = _ex2().bp;
+ 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:
void ex::construct_from_long(long i)
{
- switch (i) { // some tiny efficiency-hack
+ 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 = _ex_2().bp;
+ bp = (basic*)_num_2_p;
++bp->refcount;
break;
case -1:
- bp = _ex_1().bp;
+ bp = (basic*)_num_1_p;
++bp->refcount;
break;
case 0:
- bp = _ex0().bp;
+ bp = (basic*)_num0_p;
++bp->refcount;
break;
case 1:
- bp = _ex1().bp;
+ bp = (basic*)_num1_p;
++bp->refcount;
break;
case 2:
- bp = _ex2().bp;
+ 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:
void ex::construct_from_ulong(unsigned long i)
{
- switch (i) { // some tiny efficiency-hack
+ switch (i) { // prefer flyweights over new objects
case 0:
- bp = _ex0().bp;
+ bp = (basic*)_num0_p;
++bp->refcount;
break;
case 1:
- bp = _ex1().bp;
+ bp = (basic*)_num1_p;
++bp->refcount;
break;
case 2:
- bp = _ex2().bp;
+ 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:
git://www.ginac.de / ginac.git / blobdiff