* Implementation of GiNaC's light-weight expression handles. */
/*
- * GiNaC Copyright (C) 1999-2000 Johannes Gutenberg University Mainz, Germany
+ * GiNaC Copyright (C) 1999-2001 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 "numeric.h"
#include "power.h"
#include "relational.h"
+#include "indexed.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
+// other ctors
//////////
-// 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
+// none (all inlined)
//////////
// functions overriding virtual functions from bases classes
// public
-/** Swap the contents of two expressions. */
+/** Efficiently swap the contents of two expressions. */
void ex::swap(ex & other)
{
debugmsg("ex swap",LOGLEVEL_MEMBER_FUNCTION);
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 << ")";
+ basic * tmpbp = bp;
+ bp = other.bp;
+ other.bp = tmpbp;
}
-void ex::printtree(std::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);
+ debugmsg("ex print", LOGLEVEL_PRINT);
GINAC_ASSERT(bp!=0);
- // os << "refcount=" << bp->refcount << " ";
- bp->printtree(os,indent);
+ bp->print(c, level);
}
-/** 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
+/** Print expression to stream in a tree-like format suitable for debugging. */
+void ex::printtree(std::ostream & os) const
{
- debugmsg("ex print csrc", LOGLEVEL_PRINT);
+ debugmsg("ex printtree", 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);
+ 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);
+ debugmsg("ex dbgprinttree", LOGLEVEL_PRINT);
GINAC_ASSERT(bp!=0);
bp->dbgprinttree();
}
return bp->has(other);
}
-int ex::degree(const symbol & s) const
+int ex::degree(const ex & s) const
{
GINAC_ASSERT(bp!=0);
return bp->degree(s);
}
-int ex::ldegree(const symbol & s) const
+int ex::ldegree(const ex & s) const
{
GINAC_ASSERT(bp!=0);
return bp->ldegree(s);
}
-ex ex::coeff(const symbol & s, int n) const
+ex ex::coeff(const ex & s, int n) const
{
GINAC_ASSERT(bp!=0);
return bp->coeff(s,n);
}
-ex ex::collect(const symbol & s) const
+ex ex::collect(const ex & s) const
{
GINAC_ASSERT(bp!=0);
return bp->collect(s);
return bp->subs(e);
}
-exvector ex::get_indices(void) const
+/** Return a vector containing the free indices of the object. */
+exvector ex::get_free_indices(void) const
{
GINAC_ASSERT(bp!=0);
- return bp->get_indices();
+ 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);
}
ex ex::simplify_ncmul(const exvector & v) const
return (*static_cast<relational *>(bp)).rhs();
}
-#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
-
-#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
-
unsigned ex::return_type(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
{
- return (new mul(*this,rh))->setflag(status_flags::dynallocated);
-}
-
-ex ex::exncmul(const ex & rh) const
-{
- return (new ncmul(*this,rh))->setflag(status_flags::dynallocated);
+ // 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);
--bp->refcount;
bp = bp2;
}
- GINAC_ASSERT(bp->refcount == 1);
+ 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)==0) {
- // cf. copy constructor
+ // cf. copy ctor
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.flags & status_flags::dynallocated)&&(other.refcount==0))
delete &const_cast<basic &>(other);
- }
} else {
if (other.flags & status_flags::dynallocated) {
- // it's on the heap, so just copy bp:
+ // ok, it is already on the heap, so just copy bp:
bp = &const_cast<basic &>(other);
} else {
// create a duplicate on the heap:
bp->setflag(status_flags::dynallocated);
}
GINAC_ASSERT(bp!=0);
- // bp->clearflag(status_flags::evaluated);
++bp->refcount;
}
GINAC_ASSERT(bp!=0);
bp->setflag(status_flags::dynallocated);
++bp->refcount;
GINAC_ASSERT((bp->flags) & status_flags::dynallocated);
- GINAC_ASSERT(bp->refcount=1);
+ 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;
bp->setflag(status_flags::dynallocated);
++bp->refcount;
GINAC_ASSERT((bp->flags) & status_flags::dynallocated);
- GINAC_ASSERT(bp->refcount=1);
+ GINAC_ASSERT(bp->refcount==1);
}
}
bp->setflag(status_flags::dynallocated);
++bp->refcount;
GINAC_ASSERT((bp->flags) & status_flags::dynallocated);
- GINAC_ASSERT(bp->refcount=1);
+ 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;
bp->setflag(status_flags::dynallocated);
++bp->refcount;
GINAC_ASSERT((bp->flags) & status_flags::dynallocated);
- GINAC_ASSERT(bp->refcount=1);
+ GINAC_ASSERT(bp->refcount==1);
}
}
bp->setflag(status_flags::dynallocated);
++bp->refcount;
GINAC_ASSERT((bp->flags) & status_flags::dynallocated);
- GINAC_ASSERT(bp->refcount=1);
+ GINAC_ASSERT(bp->refcount==1);
}
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
git://www.ginac.de / ginac.git / blobdiff