The 'level' argument was modeled after that of the eval() methods
(removed in
6c946d4c). It has never been very useful except for
confusing developers and it hasn't been documented in the tutorial.
Moreover, I have no indication that it has ever been used.
12 files changed:
ex eval() const override;
ex evalm() const override;
ex series(const relational & r, int order, unsigned options = 0) const override;
ex eval() const override;
ex evalm() const override;
ex series(const relational & r, int order, unsigned options = 0) const override;
- ex normal(exmap & repl, exmap & rev_lookup, int level=0) const override;
+ ex normal(exmap & repl, exmap & rev_lookup) const override;
numeric integer_content() const override;
ex smod(const numeric &xi) const override;
numeric max_coefficient() const override;
numeric integer_content() const override;
ex smod(const numeric &xi) const override;
numeric max_coefficient() const override;
virtual ex series(const relational & r, int order, unsigned options = 0) const;
// rational functions
virtual ex series(const relational & r, int order, unsigned options = 0) const;
// rational functions
- virtual ex normal(exmap & repl, exmap & rev_lookup, int level = 0) const;
+ virtual ex normal(exmap & repl, exmap & rev_lookup) const;
virtual ex to_rational(exmap & repl) const;
virtual ex to_polynomial(exmap & repl) const;
virtual ex to_rational(exmap & repl) const;
virtual ex to_polynomial(exmap & repl) const;
ex series(const ex & r, int order, unsigned options = 0) const;
// rational functions
ex series(const ex & r, int order, unsigned options = 0) const;
// rational functions
- ex normal(int level = 0) const;
ex to_rational(exmap & repl) const;
ex to_rational(lst & repl_lst) const;
ex to_polynomial(exmap & repl) const;
ex to_rational(exmap & repl) const;
ex to_rational(lst & repl_lst) const;
ex to_polynomial(exmap & repl) const;
inline ex numer_denom(const ex & thisex)
{ return thisex.numer_denom(); }
inline ex numer_denom(const ex & thisex)
{ return thisex.numer_denom(); }
-inline ex normal(const ex & thisex, int level=0)
-{ return thisex.normal(level); }
+inline ex normal(const ex & thisex)
+{ return thisex.normal(); }
inline ex to_rational(const ex & thisex, lst & repl_lst)
{ return thisex.to_rational(repl_lst); }
inline ex to_rational(const ex & thisex, lst & repl_lst)
{ return thisex.to_rational(repl_lst); }
ex imag_part() const override;
ex evalm() const override;
ex series(const relational & s, int order, unsigned options = 0) const override;
ex imag_part() const override;
ex evalm() const override;
ex series(const relational & s, int order, unsigned options = 0) const override;
- ex normal(exmap & repl, exmap & rev_lookup, int level = 0) const override;
+ ex normal(exmap & repl, exmap & rev_lookup) const override;
numeric integer_content() const override;
ex smod(const numeric &xi) const override;
numeric max_coefficient() const override;
numeric integer_content() const override;
ex smod(const numeric &xi) const override;
numeric max_coefficient() const override;
/** Function object to be applied by basic::normal(). */
struct normal_map_function : public map_function {
/** Function object to be applied by basic::normal(). */
struct normal_map_function : public map_function {
- int level;
- normal_map_function(int l) : level(l) {}
- ex operator()(const ex & e) override { return normal(e, level); }
+ ex operator()(const ex & e) override { return normal(e); }
};
/** Default implementation of ex::normal(). It normalizes the children and
* replaces the object with a temporary symbol.
* @see ex::normal */
};
/** Default implementation of ex::normal(). It normalizes the children and
* replaces the object with a temporary symbol.
* @see ex::normal */
-ex basic::normal(exmap & repl, exmap & rev_lookup, int level) const
+ex basic::normal(exmap & repl, exmap & rev_lookup) const
{
if (nops() == 0)
return dynallocate<lst>({replace_with_symbol(*this, repl, rev_lookup), _ex1});
{
if (nops() == 0)
return dynallocate<lst>({replace_with_symbol(*this, repl, rev_lookup), _ex1});
- else {
- if (level == 1)
- return dynallocate<lst>({replace_with_symbol(*this, repl, rev_lookup), _ex1});
- else if (level == -max_recursion_level)
- throw(std::runtime_error("max recursion level reached"));
- else {
- normal_map_function map_normal(level - 1);
- return dynallocate<lst>({replace_with_symbol(map(map_normal), repl, rev_lookup), _ex1});
- }
- }
+
+ normal_map_function map_normal;
+ return dynallocate<lst>({replace_with_symbol(map(map_normal), repl, rev_lookup), _ex1});
}
/** Implementation of ex::normal() for symbols. This returns the unmodified symbol.
* @see ex::normal */
}
/** Implementation of ex::normal() for symbols. This returns the unmodified symbol.
* @see ex::normal */
-ex symbol::normal(exmap & repl, exmap & rev_lookup, int level) const
+ex symbol::normal(exmap & repl, exmap & rev_lookup) const
{
return dynallocate<lst>({*this, _ex1});
}
{
return dynallocate<lst>({*this, _ex1});
}
* into re+I*im and replaces I and non-rational real numbers with a temporary
* symbol.
* @see ex::normal */
* into re+I*im and replaces I and non-rational real numbers with a temporary
* symbol.
* @see ex::normal */
-ex numeric::normal(exmap & repl, exmap & rev_lookup, int level) const
+ex numeric::normal(exmap & repl, exmap & rev_lookup) const
{
numeric num = numer();
ex numex = num;
{
numeric num = numer();
ex numex = num;
/** Implementation of ex::normal() for a sum. It expands terms and performs
* fractional addition.
* @see ex::normal */
/** Implementation of ex::normal() for a sum. It expands terms and performs
* fractional addition.
* @see ex::normal */
-ex add::normal(exmap & repl, exmap & rev_lookup, int level) const
+ex add::normal(exmap & repl, exmap & rev_lookup) const
- if (level == 1)
- return dynallocate<lst>({replace_with_symbol(*this, repl, rev_lookup), _ex1});
- else if (level == -max_recursion_level)
- throw(std::runtime_error("max recursion level reached"));
-
// Normalize children and split each one into numerator and denominator
exvector nums, dens;
nums.reserve(seq.size()+1);
dens.reserve(seq.size()+1);
for (auto & it : seq) {
// Normalize children and split each one into numerator and denominator
exvector nums, dens;
nums.reserve(seq.size()+1);
dens.reserve(seq.size()+1);
for (auto & it : seq) {
- ex n = ex_to<basic>(recombine_pair_to_ex(it)).normal(repl, rev_lookup, level-1);
+ ex n = ex_to<basic>(recombine_pair_to_ex(it)).normal(repl, rev_lookup);
nums.push_back(n.op(0));
dens.push_back(n.op(1));
}
nums.push_back(n.op(0));
dens.push_back(n.op(1));
}
- ex n = ex_to<numeric>(overall_coeff).normal(repl, rev_lookup, level-1);
+ ex n = ex_to<numeric>(overall_coeff).normal(repl, rev_lookup);
nums.push_back(n.op(0));
dens.push_back(n.op(1));
GINAC_ASSERT(nums.size() == dens.size());
nums.push_back(n.op(0));
dens.push_back(n.op(1));
GINAC_ASSERT(nums.size() == dens.size());
/** Implementation of ex::normal() for a product. It cancels common factors
* from fractions.
* @see ex::normal() */
/** Implementation of ex::normal() for a product. It cancels common factors
* from fractions.
* @see ex::normal() */
-ex mul::normal(exmap & repl, exmap & rev_lookup, int level) const
+ex mul::normal(exmap & repl, exmap & rev_lookup) const
- if (level == 1)
- return dynallocate<lst>({replace_with_symbol(*this, repl, rev_lookup), _ex1});
- else if (level == -max_recursion_level)
- throw(std::runtime_error("max recursion level reached"));
-
// Normalize children, separate into numerator and denominator
exvector num; num.reserve(seq.size());
exvector den; den.reserve(seq.size());
ex n;
for (auto & it : seq) {
// Normalize children, separate into numerator and denominator
exvector num; num.reserve(seq.size());
exvector den; den.reserve(seq.size());
ex n;
for (auto & it : seq) {
- n = ex_to<basic>(recombine_pair_to_ex(it)).normal(repl, rev_lookup, level-1);
+ n = ex_to<basic>(recombine_pair_to_ex(it)).normal(repl, rev_lookup);
num.push_back(n.op(0));
den.push_back(n.op(1));
}
num.push_back(n.op(0));
den.push_back(n.op(1));
}
- n = ex_to<numeric>(overall_coeff).normal(repl, rev_lookup, level-1);
+ n = ex_to<numeric>(overall_coeff).normal(repl, rev_lookup);
num.push_back(n.op(0));
den.push_back(n.op(1));
num.push_back(n.op(0));
den.push_back(n.op(1));
* distributes integer exponents to numerator and denominator, and replaces
* non-integer powers by temporary symbols.
* @see ex::normal */
* distributes integer exponents to numerator and denominator, and replaces
* non-integer powers by temporary symbols.
* @see ex::normal */
-ex power::normal(exmap & repl, exmap & rev_lookup, int level) const
+ex power::normal(exmap & repl, exmap & rev_lookup) const
- if (level == 1)
- return dynallocate<lst>({replace_with_symbol(*this, repl, rev_lookup), _ex1});
- else if (level == -max_recursion_level)
- throw(std::runtime_error("max recursion level reached"));
-
// Normalize basis and exponent (exponent gets reassembled)
// Normalize basis and exponent (exponent gets reassembled)
- ex n_basis = ex_to<basic>(basis).normal(repl, rev_lookup, level-1);
- ex n_exponent = ex_to<basic>(exponent).normal(repl, rev_lookup, level-1);
+ ex n_basis = ex_to<basic>(basis).normal(repl, rev_lookup);
+ ex n_exponent = ex_to<basic>(exponent).normal(repl, rev_lookup);
n_exponent = n_exponent.op(0) / n_exponent.op(1);
if (n_exponent.info(info_flags::integer)) {
n_exponent = n_exponent.op(0) / n_exponent.op(1);
if (n_exponent.info(info_flags::integer)) {
/** Implementation of ex::normal() for pseries. It normalizes each coefficient
* and replaces the series by a temporary symbol.
* @see ex::normal */
/** Implementation of ex::normal() for pseries. It normalizes each coefficient
* and replaces the series by a temporary symbol.
* @see ex::normal */
-ex pseries::normal(exmap & repl, exmap & rev_lookup, int level) const
+ex pseries::normal(exmap & repl, exmap & rev_lookup) const
{
epvector newseq;
for (auto & it : seq) {
{
epvector newseq;
for (auto & it : seq) {
* expression can be treated as a rational function). normal() is applied
* recursively to arguments of functions etc.
*
* expression can be treated as a rational function). normal() is applied
* recursively to arguments of functions etc.
*
- * @param level maximum depth of recursion
* @return normalized expression */
* @return normalized expression */
-ex ex::normal(int level) const
{
exmap repl, rev_lookup;
{
exmap repl, rev_lookup;
- ex e = bp->normal(repl, rev_lookup, level);
+ ex e = bp->normal(repl, rev_lookup);
GINAC_ASSERT(is_a<lst>(e));
// Re-insert replaced symbols
GINAC_ASSERT(is_a<lst>(e));
// Re-insert replaced symbols
{
exmap repl, rev_lookup;
{
exmap repl, rev_lookup;
- ex e = bp->normal(repl, rev_lookup, 0);
+ ex e = bp->normal(repl, rev_lookup);
GINAC_ASSERT(is_a<lst>(e));
// Re-insert replaced symbols
GINAC_ASSERT(is_a<lst>(e));
// Re-insert replaced symbols
{
exmap repl, rev_lookup;
{
exmap repl, rev_lookup;
- ex e = bp->normal(repl, rev_lookup, 0);
+ ex e = bp->normal(repl, rev_lookup);
GINAC_ASSERT(is_a<lst>(e));
// Re-insert replaced symbols
GINAC_ASSERT(is_a<lst>(e));
// Re-insert replaced symbols
{
exmap repl, rev_lookup;
{
exmap repl, rev_lookup;
- ex e = bp->normal(repl, rev_lookup, 0);
+ ex e = bp->normal(repl, rev_lookup);
GINAC_ASSERT(is_a<lst>(e));
// Re-insert replaced symbols
GINAC_ASSERT(is_a<lst>(e));
// Re-insert replaced symbols
ex eval() 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 eval() 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 normal(exmap & repl, exmap & rev_lookup) const override;
ex to_rational(exmap & repl) const override;
ex to_polynomial(exmap & repl) const override;
numeric integer_content() const override;
ex to_rational(exmap & repl) const override;
ex to_polynomial(exmap & repl) const override;
numeric integer_content() const override;
ex series(const relational & s, int order, unsigned options = 0) const override;
ex subs(const exmap & m, unsigned options = 0) const override;
bool has(const ex & other, unsigned options = 0) const override;
ex series(const relational & s, int order, unsigned options = 0) const override;
ex subs(const exmap & m, unsigned options = 0) const override;
bool has(const ex & other, unsigned options = 0) const override;
- ex normal(exmap & repl, exmap & rev_lookup, int level = 0) const override;
+ ex normal(exmap & repl, exmap & rev_lookup) const override;
ex to_rational(exmap & repl) const override;
ex to_polynomial(exmap & repl) const override;
ex conjugate() const override;
ex to_rational(exmap & repl) const override;
ex to_polynomial(exmap & repl) const override;
ex conjugate() 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 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;
+ ex normal(exmap & repl, exmap & rev_lookup) const override;
ex expand(unsigned options = 0) const override;
ex conjugate() const override;
ex real_part() const override;
ex expand(unsigned options = 0) const override;
ex conjugate() const override;
ex real_part() const override;
ex series(const relational & r, int order, unsigned options = 0) const override { return inherited::series(r, order, options); }
// rational functions
ex series(const relational & r, int order, unsigned options = 0) const override { return inherited::series(r, order, options); }
// rational functions
- ex normal(exmap & repl, exmap & rev_lookup, int level = 0) const override { return inherited::normal(repl, rev_lookup, level); }
+ ex normal(exmap & repl, exmap & rev_lookup) const override { return inherited::normal(repl, rev_lookup); }
ex to_rational(exmap & repl) const override { return inherited::to_rational(repl); }
ex to_polynomial(exmap & repl) const override { return inherited::to_polynomial(repl); }
ex to_rational(exmap & repl) const override { return inherited::to_rational(repl); }
ex to_polynomial(exmap & repl) const override { return inherited::to_polynomial(repl); }
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 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;
+ ex normal(exmap & repl, exmap & rev_lookup) const override;
ex to_rational(exmap & repl) const override;
ex to_polynomial(exmap & repl) const override;
ex conjugate() const override;
ex to_rational(exmap & repl) const override;
ex to_polynomial(exmap & repl) const override;
ex conjugate() const override;
.BI nops( expression )
\- number of operands in expression
.br
.BI nops( expression )
\- number of operands in expression
.br
-.BI normal( "expression [" ", " level] )
+.BI normal( expression )
\- rational function normalization
.br
.BI numer( expression )
\- rational function normalization
.br
.BI numer( expression )
static ex f_ldegree(const exprseq &e) {return e[0].ldegree(e[1]);}
static ex f_lsolve(const exprseq &e) {return lsolve(e[0], e[1]);}
static ex f_nops(const exprseq &e) {return e[0].nops();}
static ex f_ldegree(const exprseq &e) {return e[0].ldegree(e[1]);}
static ex f_lsolve(const exprseq &e) {return lsolve(e[0], e[1]);}
static ex f_nops(const exprseq &e) {return e[0].nops();}
-static ex f_normal1(const exprseq &e) {return e[0].normal();}
+static ex f_normal(const exprseq &e) {return e[0].normal();}
static ex f_numer(const exprseq &e) {return e[0].numer();}
static ex f_numer_denom(const exprseq &e) {return e[0].numer_denom();}
static ex f_pow(const exprseq &e) {return pow(e[0], e[1]);}
static ex f_numer(const exprseq &e) {return e[0].numer();}
static ex f_numer_denom(const exprseq &e) {return e[0].numer_denom();}
static ex f_pow(const exprseq &e) {return pow(e[0], e[1]);}
throw std::runtime_error("FAIL");
}
throw std::runtime_error("FAIL");
}
-static ex f_normal2(const exprseq &e)
-{
- CHECK_ARG(1, numeric, normal);
- return e[0].normal(ex_to<numeric>(e[1]).to_int());
-}
-
static ex f_op(const exprseq &e)
{
CHECK_ARG(1, numeric, op);
static ex f_op(const exprseq &e)
{
CHECK_ARG(1, numeric, op);
{"map", f_map, 2},
{"match", f_match, 2},
{"nops", f_nops, 1},
{"map", f_map, 2},
{"match", f_match, 2},
{"nops", f_nops, 1},
- {"normal", f_normal1, 1},
- {"normal", f_normal2, 2},
+ {"normal", f_normal, 1},
{"numer", f_numer, 1},
{"numer_denom", f_numer_denom, 1},
{"op", f_op, 2},
{"numer", f_numer, 1},
{"numer_denom", f_numer_denom, 1},
{"op", f_op, 2},