* Implementation of GiNaC's light-weight expression handles. */
/*
- * GiNaC Copyright (C) 1999-2003 Johannes Gutenberg University Mainz, Germany
+ * GiNaC Copyright (C) 1999-2008 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 "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 "utils.h"
namespace GiNaC {
ex ex::expand(unsigned options) const
{
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;
+ return *this;
else
return bp->expand(options);
}
/** Check whether expression matches a specified pattern. */
bool ex::match(const ex & pattern) const
{
- lst repl_lst;
+ exmap repl_lst;
return bp->match(pattern, repl_lst);
}
* 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
+bool ex::find(const ex & pattern, exset& found) const
{
if (match(pattern)) {
- found.append(*this);
- found.sort();
- found.unique();
+ found.insert(*this);
return true;
}
bool any_found = false;
ex ex::subs(const ex & e, unsigned options) const
{
if (e.info(info_flags::relation_equal)) {
+
+ // Argument is a relation: convert it to a map
exmap m;
- const ex & s = e.lhs();
- m.insert(std::make_pair(s, e.rhs()));
+ const ex & s = e.op(0);
+ m.insert(std::make_pair(s, e.op(1)));
+
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;
+
return bp->subs(m, options);
- } else if (!e.info(info_flags::list))
- throw(std::invalid_argument("basic::subs(ex): argument must be a list"));
- // Convert the list 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.lhs();
- m.insert(std::make_pair(s, r.rhs()));
+ } else if (e.info(info_flags::list)) {
- // 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;
+ // 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)));
+
+ // 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;
- return bp->subs(m, options);
+ return bp->subs(m, options);
+
+ } else
+ throw(std::invalid_argument("ex::subs(ex): argument must be a relation_equal or a list"));
}
/** Traverse expression tree with given visitor, preorder traversal. */
return bp->op(1);
}
+/** Check whether expression is a polynomial. */
+bool ex::is_polynomial(const ex & vars) const
+{
+ 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);
+}
+
+/** Check whether expression is zero or zero matrix. */
+bool ex::is_zero_matrix() const
+{
+ 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
{
GINAC_ASSERT(bp->flags & status_flags::dynallocated);
bp.makewritable();
- GINAC_ASSERT(bp->refcount == 1);
+ GINAC_ASSERT(bp->get_refcount() == 1);
}
/** Share equal objects between expressions.
- * @see ex::compare(const basic &) */
+ * @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->refcount <= other.bp->refcount)
+ if (bp->get_refcount() <= other.bp->get_refcount())
bp = other.bp;
else
other.bp = bp;
// 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.refcount==0) && (other.flags & status_flags::dynallocated))
+ 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
// on the heap.
basic *bp = other.duplicate();
bp->setflag(status_flags::dynallocated);
- GINAC_ASSERT(bp->refcount == 0);
+ GINAC_ASSERT(bp->get_refcount() == 0);
return bp;
}
}
{
switch (i) { // prefer flyweights over new objects
case -12:
- return const_cast<numeric &>(_num_12);
+ return *const_cast<numeric *>(_num_12_p);
case -11:
- return const_cast<numeric &>(_num_11);
+ return *const_cast<numeric *>(_num_11_p);
case -10:
- return const_cast<numeric &>(_num_10);
+ return *const_cast<numeric *>(_num_10_p);
case -9:
- return const_cast<numeric &>(_num_9);
+ return *const_cast<numeric *>(_num_9_p);
case -8:
- return const_cast<numeric &>(_num_8);
+ return *const_cast<numeric *>(_num_8_p);
case -7:
- return const_cast<numeric &>(_num_7);
+ return *const_cast<numeric *>(_num_7_p);
case -6:
- return const_cast<numeric &>(_num_6);
+ return *const_cast<numeric *>(_num_6_p);
case -5:
- return const_cast<numeric &>(_num_5);
+ return *const_cast<numeric *>(_num_5_p);
case -4:
- return const_cast<numeric &>(_num_4);
+ return *const_cast<numeric *>(_num_4_p);
case -3:
- return const_cast<numeric &>(_num_3);
+ return *const_cast<numeric *>(_num_3_p);
case -2:
- return const_cast<numeric &>(_num_2);
+ return *const_cast<numeric *>(_num_2_p);
case -1:
- return const_cast<numeric &>(_num_1);
+ return *const_cast<numeric *>(_num_1_p);
case 0:
- return const_cast<numeric &>(_num0);
+ return *const_cast<numeric *>(_num0_p);
case 1:
- return const_cast<numeric &>(_num1);
+ return *const_cast<numeric *>(_num1_p);
case 2:
- return const_cast<numeric &>(_num2);
+ return *const_cast<numeric *>(_num2_p);
case 3:
- return const_cast<numeric &>(_num3);
+ return *const_cast<numeric *>(_num3_p);
case 4:
- return const_cast<numeric &>(_num4);
+ return *const_cast<numeric *>(_num4_p);
case 5:
- return const_cast<numeric &>(_num5);
+ return *const_cast<numeric *>(_num5_p);
case 6:
- return const_cast<numeric &>(_num6);
+ return *const_cast<numeric *>(_num6_p);
case 7:
- return const_cast<numeric &>(_num7);
+ return *const_cast<numeric *>(_num7_p);
case 8:
- return const_cast<numeric &>(_num8);
+ return *const_cast<numeric *>(_num8_p);
case 9:
- return const_cast<numeric &>(_num9);
+ return *const_cast<numeric *>(_num9_p);
case 10:
- return const_cast<numeric &>(_num10);
+ return *const_cast<numeric *>(_num10_p);
case 11:
- return const_cast<numeric &>(_num11);
+ return *const_cast<numeric *>(_num11_p);
case 12:
- return const_cast<numeric &>(_num12);
+ return *const_cast<numeric *>(_num12_p);
default:
basic *bp = new numeric(i);
bp->setflag(status_flags::dynallocated);
- GINAC_ASSERT(bp->refcount == 0);
+ GINAC_ASSERT(bp->get_refcount() == 0);
return *bp;
}
}
{
switch (i) { // prefer flyweights over new objects
case 0:
- return const_cast<numeric &>(_num0);
+ return *const_cast<numeric *>(_num0_p);
case 1:
- return const_cast<numeric &>(_num1);
+ return *const_cast<numeric *>(_num1_p);
case 2:
- return const_cast<numeric &>(_num2);
+ return *const_cast<numeric *>(_num2_p);
case 3:
- return const_cast<numeric &>(_num3);
+ return *const_cast<numeric *>(_num3_p);
case 4:
- return const_cast<numeric &>(_num4);
+ return *const_cast<numeric *>(_num4_p);
case 5:
- return const_cast<numeric &>(_num5);
+ return *const_cast<numeric *>(_num5_p);
case 6:
- return const_cast<numeric &>(_num6);
+ return *const_cast<numeric *>(_num6_p);
case 7:
- return const_cast<numeric &>(_num7);
+ return *const_cast<numeric *>(_num7_p);
case 8:
- return const_cast<numeric &>(_num8);
+ return *const_cast<numeric *>(_num8_p);
case 9:
- return const_cast<numeric &>(_num9);
+ return *const_cast<numeric *>(_num9_p);
case 10:
- return const_cast<numeric &>(_num10);
+ return *const_cast<numeric *>(_num10_p);
case 11:
- return const_cast<numeric &>(_num11);
+ return *const_cast<numeric *>(_num11_p);
case 12:
- return const_cast<numeric &>(_num12);
+ return *const_cast<numeric *>(_num12_p);
default:
basic *bp = new numeric(i);
bp->setflag(status_flags::dynallocated);
- GINAC_ASSERT(bp->refcount == 0);
+ GINAC_ASSERT(bp->get_refcount() == 0);
return *bp;
}
}
{
switch (i) { // prefer flyweights over new objects
case -12:
- return const_cast<numeric &>(_num_12);
+ return *const_cast<numeric *>(_num_12_p);
case -11:
- return const_cast<numeric &>(_num_11);
+ return *const_cast<numeric *>(_num_11_p);
case -10:
- return const_cast<numeric &>(_num_10);
+ return *const_cast<numeric *>(_num_10_p);
case -9:
- return const_cast<numeric &>(_num_9);
+ return *const_cast<numeric *>(_num_9_p);
case -8:
- return const_cast<numeric &>(_num_8);
+ return *const_cast<numeric *>(_num_8_p);
case -7:
- return const_cast<numeric &>(_num_7);
+ return *const_cast<numeric *>(_num_7_p);
case -6:
- return const_cast<numeric &>(_num_6);
+ return *const_cast<numeric *>(_num_6_p);
case -5:
- return const_cast<numeric &>(_num_5);
+ return *const_cast<numeric *>(_num_5_p);
case -4:
- return const_cast<numeric &>(_num_4);
+ return *const_cast<numeric *>(_num_4_p);
case -3:
- return const_cast<numeric &>(_num_3);
+ return *const_cast<numeric *>(_num_3_p);
case -2:
- return const_cast<numeric &>(_num_2);
+ return *const_cast<numeric *>(_num_2_p);
case -1:
- return const_cast<numeric &>(_num_1);
+ return *const_cast<numeric *>(_num_1_p);
case 0:
- return const_cast<numeric &>(_num0);
+ return *const_cast<numeric *>(_num0_p);
case 1:
- return const_cast<numeric &>(_num1);
+ return *const_cast<numeric *>(_num1_p);
case 2:
- return const_cast<numeric &>(_num2);
+ return *const_cast<numeric *>(_num2_p);
case 3:
- return const_cast<numeric &>(_num3);
+ return *const_cast<numeric *>(_num3_p);
case 4:
- return const_cast<numeric &>(_num4);
+ return *const_cast<numeric *>(_num4_p);
case 5:
- return const_cast<numeric &>(_num5);
+ return *const_cast<numeric *>(_num5_p);
case 6:
- return const_cast<numeric &>(_num6);
+ return *const_cast<numeric *>(_num6_p);
case 7:
- return const_cast<numeric &>(_num7);
+ return *const_cast<numeric *>(_num7_p);
case 8:
- return const_cast<numeric &>(_num8);
+ return *const_cast<numeric *>(_num8_p);
case 9:
- return const_cast<numeric &>(_num9);
+ return *const_cast<numeric *>(_num9_p);
case 10:
- return const_cast<numeric &>(_num10);
+ return *const_cast<numeric *>(_num10_p);
case 11:
- return const_cast<numeric &>(_num11);
+ return *const_cast<numeric *>(_num11_p);
case 12:
- return const_cast<numeric &>(_num12);
+ return *const_cast<numeric *>(_num12_p);
default:
basic *bp = new numeric(i);
bp->setflag(status_flags::dynallocated);
- GINAC_ASSERT(bp->refcount == 0);
+ GINAC_ASSERT(bp->get_refcount() == 0);
return *bp;
}
}
{
switch (i) { // prefer flyweights over new objects
case 0:
- return const_cast<numeric &>(_num0);
+ return *const_cast<numeric *>(_num0_p);
case 1:
- return const_cast<numeric &>(_num1);
+ return *const_cast<numeric *>(_num1_p);
case 2:
- return const_cast<numeric &>(_num2);
+ return *const_cast<numeric *>(_num2_p);
case 3:
- return const_cast<numeric &>(_num3);
+ return *const_cast<numeric *>(_num3_p);
case 4:
- return const_cast<numeric &>(_num4);
+ return *const_cast<numeric *>(_num4_p);
case 5:
- return const_cast<numeric &>(_num5);
+ return *const_cast<numeric *>(_num5_p);
case 6:
- return const_cast<numeric &>(_num6);
+ return *const_cast<numeric *>(_num6_p);
case 7:
- return const_cast<numeric &>(_num7);
+ return *const_cast<numeric *>(_num7_p);
case 8:
- return const_cast<numeric &>(_num8);
+ return *const_cast<numeric *>(_num8_p);
case 9:
- return const_cast<numeric &>(_num9);
+ return *const_cast<numeric *>(_num9_p);
case 10:
- return const_cast<numeric &>(_num10);
+ return *const_cast<numeric *>(_num10_p);
case 11:
- return const_cast<numeric &>(_num11);
+ return *const_cast<numeric *>(_num11_p);
case 12:
- return const_cast<numeric &>(_num12);
+ return *const_cast<numeric *>(_num12_p);
default:
basic *bp = new numeric(i);
bp->setflag(status_flags::dynallocated);
- GINAC_ASSERT(bp->refcount == 0);
+ GINAC_ASSERT(bp->get_refcount() == 0);
return *bp;
}
}
{
basic *bp = new numeric(d);
bp->setflag(status_flags::dynallocated);
- GINAC_ASSERT(bp->refcount == 0);
+ GINAC_ASSERT(bp->get_refcount() == 0);
return *bp;
}
-ptr<basic> 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
- return parsed_ex.bp;
-}
-
//////////
// static member variables
//////////
git://www.ginac.de / ginac.git / blobdiff