* 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 <iostream>
#include <stdexcept>
-#include "ex.h"
+#if defined(VERBOSE)
+# define GINAC_CONDITIONAL_INLINE
+# include "ex.h"
+# undef GINAC_CONDITIONAL_INLINE
+#else
+# include "ex.h"
+#endif
+
#include "add.h"
#include "mul.h"
#include "ncmul.h"
#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;
+ basic * tmpbp = bp;
+ bp = other.bp;
+ other.bp = tmpbp;
}
/** Output formatted to be useful as ginsh input. */
bp->print(os,upper_precedence);
}
+/** Unreadable output with detailed type information. */
void ex::printraw(std::ostream & os) const
{
debugmsg("ex printraw",LOGLEVEL_PRINT);
os << ")";
}
+/** Very detailed and unreadable output with type information and all this. */
void ex::printtree(std::ostream & os, unsigned indent) const
{
debugmsg("ex printtree",LOGLEVEL_PRINT);
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);
++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