To evaluate them using floating-point arithmetic you need to call
@example
-ex ex::evalf(int level = 0) const;
+ex ex::evalf() const;
@end example
@cindex @code{Digits}
@example
bool info(unsigned inf) const override;
-ex evalf(int level = 0) const override;
+ex evalf() const override;
ex series(const relational & r, int order, unsigned options = 0) const override;
ex derivative(const symbol & s) const override;
@end example
/** Function object to be applied by basic::evalf(). */
struct evalf_map_function : public map_function {
- int level;
- evalf_map_function(int l) : level(l) {}
- ex operator()(const ex & e) override { return evalf(e, level); }
+ ex operator()(const ex & e) override { return evalf(e); }
};
/** Evaluate object numerically. */
-ex basic::evalf(int level) const
+ex basic::evalf() const
{
if (nops() == 0)
return *this;
else {
- if (level == 1)
- return *this;
- else if (level == -max_recursion_level)
- throw(std::runtime_error("max recursion level reached"));
- else {
- evalf_map_function map_evalf(level - 1);
- return map(map_evalf);
- }
+ evalf_map_function map_evalf;
+ return map(map_evalf);
}
}
// evaluation
virtual ex eval() const;
- virtual ex evalf(int level = 0) const;
+ virtual ex evalf() const;
virtual ex evalm() const;
virtual ex eval_integ() const;
protected:
return inherited::info(inf);
}
-ex constant::evalf(int level) const
+ex constant::evalf() const
{
if (ef!=nullptr) {
return ef();
// functions overriding virtual functions from base classes
public:
bool info(unsigned inf) const override;
- ex evalf(int level = 0) const override;
+ ex evalf() const override;
bool is_polynomial(const ex & var) const override;
ex conjugate() const override;
ex real_part() const override;
// evaluation
ex eval() const { return bp->eval(); }
- ex evalf(int level = 0) const { return bp->evalf(level); }
+ ex evalf() const { return bp->evalf(); }
ex evalm() const { return bp->evalm(); }
ex eval_ncmul(const exvector & v) const { return bp->eval_ncmul(v); }
ex eval_integ() const { return bp->eval_integ(); }
inline ex eval(const ex & thisex)
{ return thisex.eval(); }
-inline ex evalf(const ex & thisex, int level = 0)
-{ return thisex.evalf(level); }
+inline ex evalf(const ex & thisex)
+{ return thisex.evalf(); }
inline ex evalm(const ex & thisex)
{ return thisex.evalm(); }
return this->hold();
}
-/** Numeric evaluation falls back to evaluation of arguments.
- * @see basic::evalf */
-ex fderivative::evalf(int level) const
-{
- return basic::evalf(level);
-}
-
/** The series expansion of derivatives falls back to Taylor expansion.
* @see basic::series */
ex fderivative::series(const relational & r, int order, unsigned options) const
public:
void print(const print_context & c, unsigned level = 0) const override;
ex eval() const override;
- ex evalf(int level = 0) const override;
ex series(const relational & r, int order, unsigned options = 0) const override;
ex thiscontainer(const exvector & v) const override;
ex thiscontainer(exvector && v) const override;
return eval_result;
}
-ex function::evalf(int level) const
+ex function::evalf() const
{
GINAC_ASSERT(serial<registered_functions().size());
const function_options &opt = registered_functions()[serial];
// Evaluate children first
exvector eseq;
- if (level == 1 || !(opt.evalf_params_first))
+ if (!opt.evalf_params_first)
eseq = seq;
- else if (level == -max_recursion_level)
- throw(std::runtime_error("max recursion level reached"));
else {
eseq.reserve(seq.size());
- --level;
for (auto & it : seq) {
- eseq.push_back(it.evalf(level));
+ eseq.push_back(it.evalf());
}
}
unsigned precedence() const override {return 70;}
ex expand(unsigned options=0) const override;
ex eval() const override;
- ex evalf(int level=0) const override;
+ ex evalf() const override;
ex eval_ncmul(const exvector & v) const override;
unsigned calchash() const override;
ex series(const relational & r, int order, unsigned options = 0) const override;
/** By default, basic::evalf would evaluate the index value but we don't want
* a.1 to become a.(1.0). */
-ex idx::evalf(int level) const
+ex idx::evalf() const
{
return *this;
}
size_t nops() const override;
ex op(size_t i) const override;
ex map(map_function & f) const override;
- ex evalf(int level = 0) const override;
+ ex evalf() const override;
ex subs(const exmap & m, unsigned options = 0) const override;
void archive(archive_node& n) const override;
void read_archive(const archive_node& n, lst& syms) override;
return this->hold();
}
-ex integral::evalf(int level) const
+ex integral::evalf() const
{
- ex ea;
- ex eb;
- ex ef;
-
- if (level==1) {
- ea = a;
- eb = b;
- ef = f;
- } else if (level == -max_recursion_level) {
- throw(runtime_error("max recursion level reached"));
- } else {
- ea = a.evalf(level-1);
- eb = b.evalf(level-1);
- ef = f.evalf(level-1);
- }
+ ex ea = a.evalf();
+ ex eb = b.evalf();
+ ex ef = f.evalf();
// 12.34 is just an arbitrary number used to check whether a number
// results after substituting a number for the integration variable.
public:
unsigned precedence() const override {return 45;}
ex eval() const override;
- ex evalf(int level=0) const override;
+ ex evalf() const override;
int degree(const ex & s) const override;
int ldegree(const ex & s) const override;
ex eval_ncmul(const exvector & v) const override;
inline ex expand(const matrix & m, unsigned options = 0)
{ return m.expand(options); }
-inline ex evalf(const matrix & m, int level = 0)
-{ return m.evalf(level); }
+inline ex evalf(const matrix & m)
+{ return m.evalf(); }
inline unsigned rows(const matrix & m)
{ return m.rows(); }
return this->hold();
}
-ex mul::evalf(int level) const
+ex mul::evalf() const
{
- if (level==1)
- return mul(seq, overall_coeff);
-
- if (level==-max_recursion_level)
- throw(std::runtime_error("max recursion level reached"));
-
epvector s;
s.reserve(seq.size());
- --level;
- for (auto & it : seq) {
- s.push_back(expair(it.rest.evalf(level), it.coeff));
- }
- return dynallocate<mul>(std::move(s), overall_coeff.evalf(level));
+ for (auto & it : seq)
+ s.push_back(expair(it.rest.evalf(), it.coeff));
+ return dynallocate<mul>(std::move(s), overall_coeff.evalf());
}
void mul::find_real_imag(ex & rp, ex & ip) const
ex coeff(const ex & s, int n = 1) const override;
bool has(const ex & other, unsigned options = 0) const override;
ex eval() const override;
- ex evalf(int level=0) const override;
+ ex evalf() const override;
ex real_part() const override;
ex imag_part() const override;
ex evalm() const override;
* currently set. In case the object already was a floating point number the
* precision is trimmed to match the currently set default.
*
- * @param level ignored, only needed for overriding basic::evalf.
* @return an ex-handle to a numeric. */
-ex numeric::evalf(int level) const
+ex numeric::evalf() const
{
- // level can safely be discarded for numeric objects.
return numeric(cln::cl_float(1.0, cln::default_float_format) * value);
}
ex coeff(const ex & s, int n = 1) const override;
bool has(const ex &other, unsigned options = 0) const override;
ex eval() const override;
- ex evalf(int level = 0) const override;
+ ex evalf() const override;
ex subs(const exmap & m, unsigned options = 0) const override { return subs_one_level(m, options); } // overwrites basic::subs() for performance reasons
ex normal(exmap & repl, exmap & rev_lookup, int level = 0) const override;
ex to_rational(exmap & repl) const override;
return this->hold();
}
-ex power::evalf(int level) const
+ex power::evalf() const
{
- ex ebasis;
+ ex ebasis = basis.evalf();
ex eexponent;
- if (level==1) {
- ebasis = basis;
+ if (!is_exactly_a<numeric>(exponent))
+ eexponent = exponent.evalf();
+ else
eexponent = exponent;
- } else if (level == -max_recursion_level) {
- throw(std::runtime_error("max recursion level reached"));
- } else {
- ebasis = basis.evalf(level-1);
- if (!is_exactly_a<numeric>(exponent))
- eexponent = exponent.evalf(level-1);
- else
- eexponent = exponent;
- }
return dynallocate<power>(ebasis, eexponent);
}
int ldegree(const ex & s) const override;
ex coeff(const ex & s, int n = 1) const override;
ex eval() const override;
- ex evalf(int level=0) const override;
+ ex evalf() const override;
ex evalm() const override;
ex series(const relational & s, int order, unsigned options = 0) const override;
ex subs(const exmap & m, unsigned options = 0) const override;
}
/** Evaluate coefficients numerically. */
-ex pseries::evalf(int level) const
+ex pseries::evalf() const
{
- if (level == 1)
- return *this;
-
- if (level == -max_recursion_level)
- throw (std::runtime_error("pseries::evalf(): recursion limit exceeded"));
-
// Construct a new series with evaluated coefficients
epvector new_seq;
new_seq.reserve(seq.size());
ex coeff(const ex &s, int n = 1) const override;
ex collect(const ex &s, bool distributed = false) const override;
ex eval() const override;
- ex evalf(int level=0) const override;
+ ex evalf() const override;
ex series(const relational & r, int order, unsigned options = 0) const override;
ex subs(const exmap & m, unsigned options = 0) const override;
ex normal(exmap & repl, exmap & rev_lookup, int level = 0) const override;
public:
// evaluation
ex eval() const override { return hold(); }
- ex evalf(int level = 0) const override { return inherited::evalf(level); }
ex evalm() const override { return inherited::evalm(); }
protected:
ex eval_ncmul(const exvector & v) const override { return hold_ncmul(v); }
public:
bool info(unsigned inf) const override;
ex eval() const override { return *this; } // for performance reasons
- ex evalf(int level = 0) const override { return *this; } // overwrites basic::evalf() for performance reasons
+ ex evalf() const override { return *this; } // overwrites basic::evalf() for performance reasons
ex series(const relational & s, int order, unsigned options = 0) const override;
ex subs(const exmap & m, unsigned options = 0) const override { return subs_one_level(m, options); } // overwrites basic::subs() for performance reasons
ex normal(exmap & repl, exmap & rev_lookup, int level = 0) const override;
.BI divide( expression ", " expression )
\- exact polynomial division
.br
-.BI evalf( "expression [" ", " level] )
+.BI evalf( expression )
\- evaluates an expression to a floating point number
.br
.BI evalm( expression )
static ex f_convert_H_to_Li(const exprseq &e) {return convert_H_to_Li(e[0], e[1]);}
static ex f_degree(const exprseq &e) {return e[0].degree(e[1]);}
static ex f_denom(const exprseq &e) {return e[0].denom();}
-static ex f_evalf1(const exprseq &e) {return e[0].evalf();}
+static ex f_evalf(const exprseq &e) {return e[0].evalf();}
static ex f_evalm(const exprseq &e) {return e[0].evalm();}
static ex f_eval_integ(const exprseq &e) {return e[0].eval_integ();}
static ex f_expand(const exprseq &e) {return e[0].expand();}
return fail();
}
-static ex f_evalf2(const exprseq &e)
-{
- CHECK_ARG(1, numeric, evalf);
- return e[0].evalf(ex_to<numeric>(e[1]).to_int());
-}
-
static ex f_find(const exprseq &e)
{
exset found;
{"diff", f_diff2, 2},
{"diff", f_diff3, 3},
{"divide", f_divide, 2},
- {"evalf", f_evalf1, 1},
- {"evalf", f_evalf2, 2},
+ {"evalf", f_evalf, 1},
{"evalm", f_evalm, 1},
{"eval_integ", f_eval_integ, 1},
{"expand", f_expand, 1},