Remove 'level' argument of normal().

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.

diff --git a/ginac/add.h b/ginac/add.h
index 30889ce948f8af62c7d5326af33deb13eeaa6665..12028be616f894e20c6dd7aa07f9d5b6e808ec84 100644 (file)
--- a/ginac/add.h
+++ b/ginac/add.h
@@ -55,7 +55,7 @@ public:
        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;

diff --git a/ginac/basic.h b/ginac/basic.h
index 9c03d61264b6fcc7d2ece30ce592b2fa2e15bcae..598058a5e8f02548bc475bd53fd01ac8a34c35cc 100644 (file)
--- a/ginac/basic.h
+++ b/ginac/basic.h
@@ -199,7 +199,7 @@ public:
        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;
 

diff --git a/ginac/ex.h b/ginac/ex.h
index a6369ef4f0c8fccbe9b90985b25b6540f50fd783..21df43059c645e886c7870c1078afaf70b6106e3 100644 (file)
--- a/ginac/ex.h
+++ b/ginac/ex.h
@@ -183,7 +183,7 @@ public:
        ex series(const ex & r, int order, unsigned options = 0) const;
 
        // rational functions
-       ex normal(int level = 0) const;
+       ex normal() const;
        ex to_rational(exmap & repl) const;
        ex to_rational(lst & repl_lst) const;
        ex to_polynomial(exmap & repl) const;
@@ -737,8 +737,8 @@ inline ex denom(const ex & thisex)
 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); }

diff --git a/ginac/mul.h b/ginac/mul.h
index 8db4281451145068bd1e5f208975adff3004dc9d..20cb54b0c01c4882a84758f69e55ccaa40a1a2d1 100644 (file)
--- a/ginac/mul.h
+++ b/ginac/mul.h
@@ -61,7 +61,7 @@ public:
        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;

diff --git a/ginac/normal.cpp b/ginac/normal.cpp
index 101af6653f068ba417558f2cdcae1b28830266d5..439a644606388ad1f70fc08d1d537f3a7189a7be 100644 (file)
--- a/ginac/normal.cpp
+++ b/ginac/normal.cpp
@@ -2024,34 +2024,25 @@ static ex replace_with_symbol(const ex & e, exmap & repl)
 
 /** 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 */
-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});
-       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 */
-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});
 }
@@ -2061,7 +2052,7 @@ ex symbol::normal(exmap & repl, exmap & rev_lookup, int level) const
  *  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;
@@ -2145,23 +2136,18 @@ static ex frac_cancel(const ex &n, const ex &d)
 /** 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) {
-               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));
        }
-       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());
@@ -2202,23 +2188,18 @@ ex add::normal(exmap & repl, exmap & rev_lookup, int level) const
 /** 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) {
-               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));
        }
-       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));
 
@@ -2231,16 +2212,11 @@ ex mul::normal(exmap & repl, exmap & rev_lookup, int level) const
  *  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)
-       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)) {
@@ -2286,7 +2262,7 @@ ex power::normal(exmap & repl, exmap & rev_lookup, int level) const
 /** 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) {
@@ -2309,13 +2285,12 @@ ex pseries::normal(exmap & repl, exmap & rev_lookup, int level) const
  *  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 */
-ex ex::normal(int level) const
+ex ex::normal() const
 {
        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
@@ -2336,7 +2311,7 @@ ex ex::numer() const
 {
        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
@@ -2356,7 +2331,7 @@ ex ex::denom() const
 {
        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
@@ -2376,7 +2351,7 @@ ex ex::numer_denom() const
 {
        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

diff --git a/ginac/numeric.h b/ginac/numeric.h
index 115987eccef56e5a2dd00528d68521a1e1eb6810..bb7d258b44b38e37925d584ee8ca1d712cd79129 100644 (file)
--- a/ginac/numeric.h
+++ b/ginac/numeric.h
@@ -106,7 +106,7 @@ public:
        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;

diff --git a/ginac/power.h b/ginac/power.h
index 19d153df9f769c05801b22f6011bcb69625998fd..d2cfd37e62e44b575eaceb01af9d0befae7ea63b 100644 (file)
--- a/ginac/power.h
+++ b/ginac/power.h
@@ -65,7 +65,7 @@ public:
        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;

diff --git a/ginac/pseries.h b/ginac/pseries.h
index e0c9443a0468a38439d9e9d49282c690c71a4d92..953c71a531d1729a683ff7ff7105d8eb93a84732 100644 (file)
--- a/ginac/pseries.h
+++ b/ginac/pseries.h
@@ -54,7 +54,7 @@ public:
        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;

diff --git a/ginac/structure.h b/ginac/structure.h
index 49df915c90ffdd5605499a5fb2d4753df4633774..444b287dee4ab7beec875517a3f1e4b7cdca06e1 100644 (file)
--- a/ginac/structure.h
+++ b/ginac/structure.h
@@ -178,7 +178,7 @@ public:
        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); }
 

diff --git a/ginac/symbol.h b/ginac/symbol.h
index b4df05b49d0fd30fa820dbba10fe4063259ff1e0..3752568fcb7dc619a01d45223559a00f94ed284b 100644 (file)
--- a/ginac/symbol.h
+++ b/ginac/symbol.h
@@ -50,7 +50,7 @@ public:
        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;

diff --git a/ginsh/ginsh.1.in b/ginsh/ginsh.1.in
index b19ca6301547211347d6ad24b5ae2c6f4676350d..09daf4ab01ca5732401b9bcc5dca6ea3770b1af5 100644 (file)
--- a/ginsh/ginsh.1.in
+++ b/ginsh/ginsh.1.in
@@ -332,7 +332,7 @@ detail here. Please refer to the GiNaC documentation.
 .BI nops( expression )
 \- number of operands in expression
 .br
-.BI normal( "expression [" ", " level] )
+.BI normal( expression )
 \- rational function normalization
 .br
 .BI numer( expression )

diff --git a/ginsh/ginsh_parser.ypp b/ginsh/ginsh_parser.ypp
index 20243ba75ebf63a166a84695e4cd9b86a637e396..2bdfc491b4c6b286a1003cc00db963e5b6db2a7e 100644 (file)
--- a/ginsh/ginsh_parser.ypp
+++ b/ginsh/ginsh_parser.ypp
@@ -343,7 +343,7 @@ static ex f_lcoeff(const exprseq &e) {return e[0].lcoeff(e[1]);}
 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]);}
@@ -480,12 +480,6 @@ static ex f_match(const exprseq &e)
        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);
@@ -626,8 +620,7 @@ static const fcn_init builtin_fcns[] = {
        {"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},