be inlined for obvious reasons.
for (unsigned i=0; i<e.nops(); i++) {
ex r = e.op(i);
if (!r.info(info_flags::relation_equal)) {
- throw(std::invalid_argument("basic::subs(ex): argument must be a list or equations"));
+ throw(std::invalid_argument("basic::subs(ex): argument must be a list of equations"));
}
ls.append(r.op(0));
lr.append(r.op(1));
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);
return bp->expand(options);
}
-bool ex::has(const ex & other) const
-{
- GINAC_ASSERT(bp!=0);
- return bp->has(other);
-}
-
-int ex::degree(const ex & s) const
-{
- GINAC_ASSERT(bp!=0);
- return bp->degree(s);
-}
-
-int ex::ldegree(const ex & s) const
-{
- GINAC_ASSERT(bp!=0);
- return bp->ldegree(s);
-}
-
-ex ex::coeff(const ex & s, int n) const
-{
- GINAC_ASSERT(bp!=0);
- return bp->coeff(s,n);
-}
-
-ex ex::collect(const ex & s, bool distributed) const
-{
- GINAC_ASSERT(bp!=0);
- return bp->collect(s, distributed);
-}
-
-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
-{
- 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 GiNaC::simplify_indexed(*this, sp);
}
-ex ex::simplify_ncmul(const exvector & v) const
-{
- GINAC_ASSERT(bp!=0);
- return bp->simplify_ncmul(v);
-}
-
ex ex::operator[](const ex & index) const
{
debugmsg("ex operator[ex]",LOGLEVEL_OPERATOR);
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)
{
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();
}
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
{
void printtree(std::ostream & os) const;
void dbgprint(void) const;
void dbgprinttree(void) const;
- bool info(unsigned inf) const;
- unsigned nops() const;
+ bool info(unsigned inf) const { return bp->info(inf); }
+ unsigned nops() const { return bp->nops(); }
ex expand(unsigned options=0) const;
- bool has(const ex & other) const;
- int degree(const ex & s) const;
- int ldegree(const ex & s) const;
- ex coeff(const ex & s, int n=1) const;
+ bool has(const ex & other) const { return bp->has(other); }
+ int degree(const ex & s) const { return bp->degree(s); }
+ int ldegree(const ex & s) const { return bp->ldegree(s); }
+ ex coeff(const ex & s, int n = 1) const { return bp->coeff(s, n); }
ex lcoeff(const ex & s) const { return coeff(s, degree(s)); }
ex tcoeff(const ex & s) const { return coeff(s, ldegree(s)); }
ex numer(void) const;
ex to_rational(lst &repl_lst) const;
ex smod(const numeric &xi) const;
numeric max_coefficient(void) const;
- ex collect(const ex & s, bool distributed = false) const;
- ex eval(int level = 0) const;
- ex evalf(int level = 0) const;
+ ex collect(const ex & s, bool distributed = false) const { return bp->collect(s, distributed); }
+ ex eval(int level = 0) const { return bp->eval(level); }
+ ex evalf(int level = 0) const { return bp->evalf(level); }
ex diff(const symbol & s, unsigned nth = 1) const;
ex series(const ex & r, int order, unsigned options = 0) const;
- ex subs(const lst & ls, const lst & lr) const;
- ex subs(const ex & e) const;
- exvector get_free_indices(void) const;
+ ex subs(const lst & ls, const lst & lr) const { return bp->subs(ls, lr); }
+ ex subs(const ex & e) const { return bp->subs(e); }
+ exvector get_free_indices(void) const { return bp->get_free_indices(); }
ex simplify_indexed(void) const;
ex simplify_indexed(const scalar_products & sp) const;
- ex simplify_ncmul(const exvector & v) const;
+ ex simplify_ncmul(const exvector & v) const { return bp->simplify_ncmul(v); }
ex operator[](const ex & index) const;
ex operator[](int i) const;
- ex op(int i) const;
+ ex op(int i) const { return bp->op(i); }
ex & let_op(int i);
ex lhs(void) const;
ex rhs(void) const;
bool is_equal(const ex & other) const;
bool is_zero(void) const { return is_equal(_ex0()); }
- unsigned return_type(void) const;
- unsigned return_type_tinfo(void) const;
- unsigned gethash(void) const;
+ unsigned return_type(void) const { return bp->return_type(); }
+ unsigned return_type_tinfo(void) const { return bp->return_type_tinfo(); }
+ unsigned gethash(void) const { return bp->gethash(); }
ex exadd(const ex & rh) const;
ex exmul(const ex & rh) const;
if (x.info(info_flags::integer)) {
// lgamma(n) -> log((n-1)!) for postitive n
if (x.info(info_flags::posint))
- return log(factorial(x.exadd(_ex_1())));
+ return log(factorial(x + _ex_1()));
else
throw (pole_error("lgamma_eval(): logarithmic pole",0));
}
GINAC_ASSERT(basis.return_type()==return_types::commutative);
}
+/** Ctor from an ex and a bare numeric. This is somewhat more efficient than
+ * the normal ctor from two ex whenever it can be used. */
power::power(const ex & lh, const numeric & rh) : basic(TINFO_power), basis(lh), exponent(rh)
{
debugmsg("power ctor from ex,numeric",LOGLEVEL_CONSTRUCT);