From: Richard Kreckel <kreckel@ginac.de>
Date: Wed, 16 Dec 2015 20:22:36 +0000 (+0100)
Subject: Make .eval() evaluate top-level only.
X-Git-Tag: release_1-7-0~7^2~36
X-Git-Url: https://www.ginac.de/ginac.git//ginac.git?p=ginac.git;a=commitdiff_plain;h=6c946d4c762f5a0d6a3b742f03556dd018d63886;ds=sidebyside

Make .eval() evaluate top-level only.

With the previous patch, some old workarounds have become unnecessary:
If all expressions are evaluated, any object which is an aggregate of
expressions will only ever have to evaluate the top level. As such, it
has become pointless to evaluate child objects of an expression prior
to doing its own term-rewriting. This patch removes the evaluation of
children from all GiNaC objects. It also removes the now superfluous
parameter 'level' of the eval methods.
---

diff --git a/check/exam_inifcns_nstdsums.cpp b/check/exam_inifcns_nstdsums.cpp
index 6e4d846a..edba7769 100644
--- a/check/exam_inifcns_nstdsums.cpp
+++ b/check/exam_inifcns_nstdsums.cpp
@@ -146,7 +146,7 @@ static unsigned inifcns_test_HLi()
 	res.append(H(lst{-2,1,3},numeric(1)/3).hold() - -Li(lst{2,1,3},lst{-numeric(1)/3,-1,1}).hold());
 	res.append(H(lst{-2,1,3},numeric(98)/100).hold() - -Li(lst{2,1,3},lst{-numeric(98)/100,-1,1}).hold());
 	res.append(H(lst{-2,1,3},numeric(245)/100).hold() - -Li(lst{2,1,3},lst{-numeric(245)/100,-1,1}).hold());
-	res.append(H(lst{-3,1,-2,0,0},numeric(3)/10).hold() - convert_H_to_Li(lst{-3,1,-2,0,0},numeric(3)/10).eval());
+	res.append(H(lst{-3,1,-2,0,0},numeric(3)/10).hold() - convert_H_to_Li(lst{-3,1,-2,0,0},numeric(3)/10));
 	
 	for (lst::const_iterator it = res.begin(); it != res.end(); it++) {
 		ex diff = abs((*it).evalf());
diff --git a/check/exam_paranoia.cpp b/check/exam_paranoia.cpp
index 6ab452ba..ad7ee8d2 100644
--- a/check/exam_paranoia.cpp
+++ b/check/exam_paranoia.cpp
@@ -73,23 +73,10 @@ static unsigned exam_paranoia2()
 	f = e*y;
 	g = f - e*y;
 
-	// After .expand(), g should be zero:
-	if (!g.expand().is_zero()) {
-		clog << "e = (x + z*x); f = e*y; expand(f - e*y) erroneously returned "
-		     << g.expand() << endl;
-		++result;
-	}
 	// After .eval(), g should be zero:
-	if (!g.eval().is_zero()) {
-		clog << "e = (x + z*x); f = e*y; eval(f - e*y) erroneously returned "
-		     << g.eval() << endl;
-		++result;
-	}
-	// This actually worked already back in April 1999.
-	// But we are *very* paranoic!
-	if (!g.expand().eval().is_zero()) {
-		clog << "e = (x + z*x); f = e*y; eval(expand(f - e*y)) erroneously returned "
-		     << g.expand().eval() << endl;
+	if (!g.is_zero()) {
+		clog << "e = (x + z*x); f = e*y; g = (f - e*y) erroneously returned g == "
+		     << g << endl;
 		++result;
 	}
 
@@ -113,16 +100,6 @@ static unsigned exam_paranoia3()
 		     << f << endl;
 		++result;
 	}
-	if (!f.eval().is_equal(y)) {
-		clog << "e = x*y - y; eval(e.subs(x == 2)) erroneously returned "
-		     << f.eval() << endl;
-		++result;
-	}
-	if (!f.expand().is_equal(y)) {
-		clog << "e = x*y - y; expand(e.subs(x == 2)) erroneously returned "
-		     << f.expand() << endl;
-		++result;
-	}
 
 	return result;
 }
@@ -143,11 +120,6 @@ static unsigned exam_paranoia4()
 		     << g << endl;
 		++result;
 	}
-	if (!g.is_zero()) {
-		clog << "e = pow(x,2) + x + 1; f = pow(x,2) + x + 1; g = e-f; g.eval() erroneously returned "
-		     << g.eval() << endl;
-		++result;
-	}
 
 	return result;
 }
@@ -264,7 +236,7 @@ static unsigned exam_paranoia10()
 	ex r;
 	
 	try {
-		r = pow(b,e).eval();
+		r = pow(b, e);
 		if (!(r-2*sqrt(ex(2))).is_zero()) {
 			clog << "2^(3/2) erroneously returned " << r << " instead of 2*sqrt(2)" << endl;
 			++result;
diff --git a/check/exam_structure.cpp b/check/exam_structure.cpp
index 56f205ec..bc5bc837 100644
--- a/check/exam_structure.cpp
+++ b/check/exam_structure.cpp
@@ -58,7 +58,7 @@ template <> void sprod::print(const print_context & c, unsigned level) const
 	c.s << "<" << sp.left << "|" << sp.right << ">";
 }
 
-template <> ex sprod::eval(int level) const
+template <> ex sprod::eval() const
 {
 	// symmetric scalar product
 	const sprod_s & sp = get_struct();
diff --git a/doc/tutorial/ginac.texi b/doc/tutorial/ginac.texi
index 0d86eeee..fd5550fb 100644
--- a/doc/tutorial/ginac.texi
+++ b/doc/tutorial/ginac.texi
@@ -838,8 +838,8 @@ some immediate simplifications.
 Internally, the anonymous evaluator in GiNaC is implemented by the methods
 
 @example
-ex ex::eval(int level = 0) const;
-ex basic::eval(int level = 0) const;
+ex ex::eval() const;
+ex basic::eval() const;
 @end example
 
 but unless you are extending GiNaC with your own classes or functions, there
@@ -8241,11 +8241,11 @@ class mystring : public basic
 @{
     ...
 public:
-    ex eval(int level = 0) const;
+    ex eval() const override;
     ...
 @};
 
-ex mystring::eval(int level) const
+ex mystring::eval() const
 @{
     string new_str;
     for (size_t i=0; i<str.length(); i++) @{
@@ -8258,19 +8258,19 @@ ex mystring::eval(int level) const
 
     if (new_str.length() == 0)
         return 0;
-    else
-        return mystring(new_str).hold();
+
+    return mystring(new_str).hold();
 @}
 @end example
 
-The @code{level} argument is used to limit the recursion depth of the
-evaluation.  We don't have any subexpressions in the @code{mystring}
-class so we are not concerned with this.  If we had, we would call the
-@code{eval()} functions of the subexpressions with @code{level - 1} as
-the argument if @code{level != 1}.  The @code{hold()} member function
-sets a flag in the object that prevents further evaluation.  Otherwise
-we might end up in an endless loop.  When you want to return the object
-unmodified, use @code{return this->hold();}.
+The @code{hold()} member function sets a flag in the object that prevents
+further evaluation.  Otherwise we might end up in an endless loop.  When you
+want to return the object unmodified, use @code{return this->hold();}.
+
+If our class had subobjects, we would have to evaluate them first (unless
+they are all of type @code{ex}, which are automatically evaluated). We don't
+have any subexpressions in the @code{mystring} class, so we are not concerned
+with this.
 
 Let's confirm that it works:
 
@@ -8293,8 +8293,8 @@ required but will make operations with objects of the class more efficient:
 @cindex @code{calchash()}
 @cindex @code{is_equal_same_type()}
 @example
-unsigned calchash() const;
-bool is_equal_same_type(const basic & other) const;
+unsigned calchash() const override;
+bool is_equal_same_type(const basic & other) const override;
 @end example
 
 The @code{calchash()} method returns an @code{unsigned} hash value for the
@@ -8315,10 +8315,10 @@ For a real algebraic class, there are probably some more functions that you
 might want to provide:
 
 @example
-bool info(unsigned inf) const;
-ex evalf(int level = 0) const;
-ex series(const relational & r, int order, unsigned options = 0) const;
-ex derivative(const symbol & s) const;
+bool info(unsigned inf) const override;
+ex evalf(int level = 0) const override;
+ex series(const relational & r, int order, unsigned options = 0) const override;
+ex derivative(const symbol & s) const override;
 @end example
 
 If your class stores sub-expressions (see the scalar product example in the
@@ -8326,11 +8326,11 @@ previous section) you will probably want to override
 
 @cindex @code{let_op()}
 @example
-size_t nops() cont;
-ex op(size_t i) const;
-ex & let_op(size_t i);
-ex subs(const lst & ls, const lst & lr, unsigned options = 0) const;
-ex map(map_function & f) const;
+size_t nops() const override;
+ex op(size_t i) const override;
+ex & let_op(size_t i) override;
+ex subs(const lst & ls, const lst & lr, unsigned options = 0) const override;
+ex map(map_function & f) const override;
 @end example
 
 @code{let_op()} is a variant of @code{op()} that allows write access. The
diff --git a/ginac/add.cpp b/ginac/add.cpp
index ed587309..2a2e2f83 100644
--- a/ginac/add.cpp
+++ b/ginac/add.cpp
@@ -326,17 +326,16 @@ ex add::coeff(const ex & s, int n) const
  *  an expression that contain a plain number.
  *  - +(;c) -> c
  *  - +(x;0) -> x
- *
- *  @param level cut-off in recursive evaluation */
-ex add::eval(int level) const
+ */
+ex add::eval() const
 {
-	if ((level == 1) && (flags & status_flags::evaluated)) {
+	if (flags & status_flags::evaluated) {
 		GINAC_ASSERT(seq.size()>0);
 		GINAC_ASSERT(seq.size()>1 || !overall_coeff.is_zero());
 		return *this;
 	}
 
-	const epvector evaled = evalchildren(level);
+	const epvector evaled = evalchildren();
 	if (unlikely(!evaled.empty())) {
 		// start over evaluating a new object
 		return dynallocate<add>(std::move(evaled), overall_coeff);
diff --git a/ginac/add.h b/ginac/add.h
index 659692b9..42761576 100644
--- a/ginac/add.h
+++ b/ginac/add.h
@@ -51,7 +51,7 @@ public:
 	int degree(const ex & s) const override;
 	int ldegree(const ex & s) const override;
 	ex coeff(const ex & s, int n=1) const override;
-	ex eval(int level=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;
diff --git a/ginac/basic.cpp b/ginac/basic.cpp
index 96cfd14c..a2be1ca5 100644
--- a/ginac/basic.cpp
+++ b/ginac/basic.cpp
@@ -410,7 +410,7 @@ ex basic::collect(const ex & s, bool distributed) const
 }
 
 /** Perform automatic non-interruptive term rewriting rules. */
-ex basic::eval(int level) const
+ex basic::eval() const
 {
 	// There is nothing to do for basic objects:
 	return hold();
diff --git a/ginac/basic.h b/ginac/basic.h
index a8062c15..0cec003a 100644
--- a/ginac/basic.h
+++ b/ginac/basic.h
@@ -135,7 +135,7 @@ public: // only const functions please (may break reference counting)
 	}
 
 	// evaluation
-	virtual ex eval(int level = 0) const;
+	virtual ex eval() const;
 	virtual ex evalf(int level = 0) const;
 	virtual ex evalm() const;
 	virtual ex eval_integ() const;
diff --git a/ginac/container.h b/ginac/container.h
index 04ab31d1..0881095a 100644
--- a/ginac/container.h
+++ b/ginac/container.h
@@ -205,7 +205,6 @@ public:
 	size_t nops() const override { return this->seq.size(); }
 	ex op(size_t i) const override;
 	ex & let_op(size_t i) override;
-	ex eval(int level = 0) const override;
 	ex subs(const exmap & m, unsigned options = 0) const override;
 
 	void read_archive(const archive_node &n, lst &sym_lst) override
@@ -336,7 +335,6 @@ protected:
 	void do_print_tree(const print_tree & c, unsigned level) const;
 	void do_print_python(const print_python & c, unsigned level) const;
 	void do_print_python_repr(const print_python_repr & c, unsigned level) const;
-	STLT evalchildren(int level) const;
 	STLT subschildren(const exmap & m, unsigned options = 0) const;
 };
 
@@ -482,15 +480,6 @@ ex & container<C>::let_op(size_t i)
 	return *it;
 }
 
-template <template <class T, class = std::allocator<T>> class C>
-ex container<C>::eval(int level) const
-{
-	if (level == 1)
-		return hold();
-	else
-		return thiscontainer(evalchildren(level));
-}
-
 template <template <class T, class = std::allocator<T>> class C>
 ex container<C>::subs(const exmap & m, unsigned options) const
 {
@@ -649,27 +638,6 @@ void container<C>::printseq(const print_context & c, char openbracket, char deli
 		c.s << closebracket;
 }
 
-template <template <class T, class = std::allocator<T>> class C>
-typename container<C>::STLT container<C>::evalchildren(int level) const
-{
-	if (level == 1)
-		return this->seq;
-	else if (level == -max_recursion_level)
-		throw std::runtime_error("max recursion level reached");
-
-	STLT s;
-	this->reserve(s, this->seq.size());
-
-	--level;
-	const_iterator it = this->seq.begin(), itend = this->seq.end();
-	while (it != itend) {
-		s.push_back(it->eval(level));
-		++it;
-	}
-
-	return s;
-}
-
 template <template <class T, class = std::allocator<T>> class C>
 typename container<C>::STLT container<C>::subschildren(const exmap & m, unsigned options) const
 {
diff --git a/ginac/ex.cpp b/ginac/ex.cpp
index 7bd8410b..c403c7f6 100644
--- a/ginac/ex.cpp
+++ b/ginac/ex.cpp
@@ -306,7 +306,7 @@ ptr<basic> ex::construct_from_basic(const basic & other)
 		// apply eval() once more. The recursion stops when eval() calls
 		// hold() or returns an object that already has its "evaluated"
 		// flag set, such as a symbol or a numeric.
-		const ex & tmpex = other.eval(1);
+		const ex & tmpex = other.eval();
 
 		// Eventually, the eval() recursion goes through the "else" branch
 		// below, which assures that the object pointed to by tmpex.bp is
diff --git a/ginac/ex.h b/ginac/ex.h
index 343fa367..6fd45c9d 100644
--- a/ginac/ex.h
+++ b/ginac/ex.h
@@ -115,7 +115,7 @@ public:
 	const_postorder_iterator postorder_end() const noexcept;
 
 	// evaluation
-	ex eval(int level = 0) const { return bp->eval(level); }
+	ex eval() const { return bp->eval(); }
 	ex evalf(int level = 0) const { return bp->evalf(level); }
 	ex evalm() const { return bp->evalm(); }
 	ex eval_ncmul(const exvector & v) const { return bp->eval_ncmul(v); }
@@ -755,8 +755,8 @@ inline ex to_polynomial(const ex & thisex, lst & repl_lst)
 inline ex collect(const ex & thisex, const ex & s, bool distributed = false)
 { return thisex.collect(s, distributed); }
 
-inline ex eval(const ex & thisex, int level = 0)
-{ return thisex.eval(level); }
+inline ex eval(const ex & thisex)
+{ return thisex.eval(); }
 
 inline ex evalf(const ex & thisex, int level = 0)
 { return thisex.evalf(level); }
diff --git a/ginac/expairseq.cpp b/ginac/expairseq.cpp
index 9ca40709..e99d21fe 100644
--- a/ginac/expairseq.cpp
+++ b/ginac/expairseq.cpp
@@ -239,12 +239,12 @@ ex expairseq::map(map_function &f) const
 }
 
 /** Perform coefficient-wise automatic term rewriting rules in this class. */
-ex expairseq::eval(int level) const
+ex expairseq::eval() const
 {
-	if ((level==1) && (flags &status_flags::evaluated))
+	if (flags &status_flags::evaluated)
 		return *this;
 
-	const epvector evaled = evalchildren(level);
+	const epvector evaled = evalchildren();
 	if (!evaled.empty())
 		return dynallocate<expairseq>(std::move(evaled), overall_coeff).setflag(status_flags::evaluated);
 	else
@@ -1048,15 +1048,11 @@ epvector expairseq::expandchildren(unsigned options) const
  *  @see expairseq::eval()
  *  @return epvector containing evaluated pairs, empty if no members
  *    had to be changed. */
-epvector expairseq::evalchildren(int level) const
+epvector expairseq::evalchildren() const
 {
-	if (level == -max_recursion_level)
-		throw(std::runtime_error("max recursion level reached"));
-
 	auto cit = seq.begin(), last = seq.end();
 	while (cit!=last) {
-		const ex evaled_rest = level==1 ? cit->rest : cit->rest.eval(level-1);
-		const expair evaled_pair = combine_ex_with_coeff_to_pair(evaled_rest, cit->coeff);
+		const expair evaled_pair = combine_ex_with_coeff_to_pair(cit->rest, cit->coeff);
 		if (unlikely(!evaled_pair.is_equal(*cit))) {
 
 			// something changed: copy seq, eval and return it
@@ -1072,8 +1068,7 @@ epvector expairseq::evalchildren(int level) const
 
 			// copy rest
 			while (cit != last) {
-				const ex evaled_rest = level==1 ? cit->rest : cit->rest.eval(level-1);
-				s.push_back(combine_ex_with_coeff_to_pair(evaled_rest, cit->coeff));
+				s.push_back(combine_ex_with_coeff_to_pair(cit->rest, cit->coeff));
 				++cit;
 			}
 			return s;
diff --git a/ginac/expairseq.h b/ginac/expairseq.h
index d33ff332..41b077d5 100644
--- a/ginac/expairseq.h
+++ b/ginac/expairseq.h
@@ -64,7 +64,7 @@ public:
 	size_t nops() const override;
 	ex op(size_t i) const override;
 	ex map(map_function & f) const override;
-	ex eval(int level=0) const override;
+	ex eval() const override;
 	ex to_rational(exmap & repl) const override;
 	ex to_polynomial(exmap & repl) const override;
 	bool match(const ex & pattern, exmap& repl_lst) const override;
@@ -119,7 +119,7 @@ protected:
 	void combine_same_terms_sorted_seq();
 	bool is_canonical() const;
 	epvector expandchildren(unsigned options) const;
-	epvector evalchildren(int level) const;
+	epvector evalchildren() const;
 	epvector subschildren(const exmap & m, unsigned options = 0) const;
 	
 // member variables
diff --git a/ginac/factor.cpp b/ginac/factor.cpp
index e96dccfa..30d7953b 100644
--- a/ginac/factor.cpp
+++ b/ginac/factor.cpp
@@ -2519,8 +2519,6 @@ struct apply_factor_map : public map_function {
 					s2 += e.op(i);
 				}
 			}
-			s1 = s1.eval();
-			s2 = s2.eval();
 			return factor(s1, options) + s2.map(*this);
 		}
 		return e.map(*this);
diff --git a/ginac/fderivative.cpp b/ginac/fderivative.cpp
index 4229d0ab..17817e10 100644
--- a/ginac/fderivative.cpp
+++ b/ginac/fderivative.cpp
@@ -139,13 +139,8 @@ void fderivative::do_print_tree(const print_tree & c, unsigned level) const
 	c.s << std::string(level + c.delta_indent, ' ') << "=====" << std::endl;
 }
 
-ex fderivative::eval(int level) const
+ex fderivative::eval() const
 {
-	if (level > 1) {
-		// first evaluate children, then we will end up here again
-		return fderivative(serial, parameter_set, evalchildren(level));
-	}
-
 	// No parameters specified? Then return the function itself
 	if (parameter_set.empty())
 		return function(serial, seq);
diff --git a/ginac/fderivative.h b/ginac/fderivative.h
index a646eacf..643fafaf 100644
--- a/ginac/fderivative.h
+++ b/ginac/fderivative.h
@@ -60,7 +60,7 @@ public:
 	// functions overriding virtual functions from base classes
 public:
 	void print(const print_context & c, unsigned level = 0) const override;
-	ex eval(int 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;
diff --git a/ginac/function.cppy b/ginac/function.cppy
index 789ca056..686a76e6 100644
--- a/ginac/function.cppy
+++ b/ginac/function.cppy
@@ -362,17 +362,12 @@ next_context:
 	}
 }
 
-ex function::eval(int level) const
+ex function::eval() const
 {
-	if ((level == 1) && (flags & status_flags::evaluated)) {
+	if (flags & status_flags::evaluated) {
 		return *this;
 	}
 
-	if (level>1) {
-		// first evaluate children, then we will end up here again
-		return function(serial,evalchildren(level));
-	}
-
 	GINAC_ASSERT(serial<registered_functions().size());
 	const function_options &opt = registered_functions()[serial];
 
diff --git a/ginac/function.hppy b/ginac/function.hppy
index b54f41f3..0f35100a 100644
--- a/ginac/function.hppy
+++ b/ginac/function.hppy
@@ -228,7 +228,7 @@ public:
 	void print(const print_context & c, unsigned level = 0) const override;
 	unsigned precedence() const override {return 70;}
 	ex expand(unsigned options=0) const override;
-	ex eval(int level=0) const override;
+	ex eval() const override;
 	ex evalf(int level=0) const override;
 	ex eval_ncmul(const exvector & v) const override;
 	unsigned calchash() const override;
diff --git a/ginac/indexed.cpp b/ginac/indexed.cpp
index ca4beff5..357528a8 100644
--- a/ginac/indexed.cpp
+++ b/ginac/indexed.cpp
@@ -260,12 +260,8 @@ int indexed::compare_same_type(const basic & other) const
 	return inherited::compare_same_type(other);
 }
 
-ex indexed::eval(int level) const
+ex indexed::eval() const
 {
-	// First evaluate children, then we will end up here again
-	if (level > 1)
-		return indexed(ex_to<symmetry>(symtree), evalchildren(level));
-
 	const ex &base = seq[0];
 
 	// If the base object is 0, the whole object is 0
diff --git a/ginac/indexed.h b/ginac/indexed.h
index a04b7425..1917de43 100644
--- a/ginac/indexed.h
+++ b/ginac/indexed.h
@@ -145,7 +145,7 @@ public:
 public:
 	unsigned precedence() const override {return 55;}
 	bool info(unsigned inf) const override;
-	ex eval(int level = 0) const override;
+	ex eval() const override;
 	ex real_part() const override;
 	ex imag_part() const override;
 	exvector get_free_indices() const override;
diff --git a/ginac/inifcns_nstdsums.cpp b/ginac/inifcns_nstdsums.cpp
index 2a207924..82a0bbd8 100644
--- a/ginac/inifcns_nstdsums.cpp
+++ b/ginac/inifcns_nstdsums.cpp
@@ -1136,7 +1136,7 @@ G_do_trafo(const std::vector<cln::cl_N>& x, const std::vector<int>& s,
 	Gparameter pendint;
 	ex result = G_transform(pendint, a, scale, gsyms, flag_trailing_zeros_only);
 	// replace dummy symbols with their values
-	result = result.eval().expand();
+	result = result.expand();
 	result = result.subs(subslst).evalf();
 	if (!is_a<numeric>(result))
 		throw std::logic_error("G_do_trafo: G_transform returned non-numeric result");
diff --git a/ginac/integral.cpp b/ginac/integral.cpp
index 81e7adef..926125bb 100644
--- a/ginac/integral.cpp
+++ b/ginac/integral.cpp
@@ -140,28 +140,18 @@ int integral::compare_same_type(const basic & other) const
 	return f.compare(o.f);
 }
 
-ex integral::eval(int level) const
+ex integral::eval() const
 {
-	if ((level==1) && (flags & status_flags::evaluated))
+	if (flags & status_flags::evaluated)
 		return *this;
-	if (level == -max_recursion_level)
-		throw(std::runtime_error("max recursion level reached"));
 
-	ex eintvar = (level==1) ? x : x.eval(level-1);
-	ex ea      = (level==1) ? a : a.eval(level-1);
-	ex eb      = (level==1) ? b : b.eval(level-1);
-	ex ef      = (level==1) ? f : f.eval(level-1);
+	if (!f.has(x) && !haswild(f))
+		return b*f-a*f;
 
-	if (!ef.has(eintvar) && !haswild(ef))
-		return eb*ef-ea*ef;
-
-	if (ea==eb)
+	if (a==b)
 		return _ex0;
 
-	if (are_ex_trivially_equal(eintvar,x) && are_ex_trivially_equal(ea,a) &&
-	    are_ex_trivially_equal(eb,b) && are_ex_trivially_equal(ef,f))
-		return this->hold();
-	return dynallocate<integral>(eintvar, ea, eb, ef).setflag(status_flags::evaluated);
+	return this->hold();
 }
 
 ex integral::evalf(int level) const
diff --git a/ginac/integral.h b/ginac/integral.h
index f76ac7fc..b2be4b43 100644
--- a/ginac/integral.h
+++ b/ginac/integral.h
@@ -41,7 +41,7 @@ public:
 	// functions overriding virtual functions from base classes
 public:
 	unsigned precedence() const override {return 45;}
-	ex eval(int level=0) const override;
+	ex eval() const override;
 	ex evalf(int level=0) const override;
 	int degree(const ex & s) const override;
 	int ldegree(const ex & s) const override;
diff --git a/ginac/matrix.cpp b/ginac/matrix.cpp
index 7d054cf1..c842885f 100644
--- a/ginac/matrix.cpp
+++ b/ginac/matrix.cpp
@@ -227,27 +227,6 @@ ex & matrix::let_op(size_t i)
 	return m[i];
 }
 
-/** Evaluate matrix entry by entry. */
-ex matrix::eval(int level) const
-{
-	// check if we have to do anything at all
-	if ((level==1)&&(flags & status_flags::evaluated))
-		return *this;
-	
-	// emergency break
-	if (level == -max_recursion_level)
-		throw (std::runtime_error("matrix::eval(): recursion limit exceeded"));
-	
-	// eval() entry by entry
-	exvector m2(row*col);
-	--level;
-	for (unsigned r=0; r<row; ++r)
-		for (unsigned c=0; c<col; ++c)
-			m2[r*col+c] = m[r*col+c].eval(level);
-	
-	return dynallocate<matrix>(row, col, std::move(m2)).setflag(status_flags::evaluated);
-}
-
 ex matrix::subs(const exmap & mp, unsigned options) const
 {
 	exvector m2(row * col);
diff --git a/ginac/matrix.h b/ginac/matrix.h
index 988e257b..5c665dd6 100644
--- a/ginac/matrix.h
+++ b/ginac/matrix.h
@@ -111,7 +111,6 @@ public:
 	size_t nops() const override;
 	ex op(size_t i) const override;
 	ex & let_op(size_t i) override;
-	ex eval(int level=0) const override;
 	ex evalm() const override {return *this;}
 	ex subs(const exmap & m, unsigned options = 0) const override;
 	ex eval_indexed(const basic & i) const override;
@@ -190,9 +189,6 @@ inline size_t nops(const matrix & m)
 inline ex expand(const matrix & m, unsigned options = 0)
 { return m.expand(options); }
 
-inline ex eval(const matrix & m, int level = 0)
-{ return m.eval(level); }
-
 inline ex evalf(const matrix & m, int level = 0)
 { return m.evalf(level); }
 
diff --git a/ginac/mul.cpp b/ginac/mul.cpp
index a83b771d..0a6fca40 100644
--- a/ginac/mul.cpp
+++ b/ginac/mul.cpp
@@ -464,17 +464,16 @@ ex mul::coeff(const ex & s, int n) const
  *  - *(+(x1,x2,...);c) -> *(+(*(x1,c),*(x2,c),...))
  *  - *(x;1) -> x
  *  - *(;c) -> c
- *
- *  @param level cut-off in recursive evaluation */
-ex mul::eval(int level) const
+ */
+ex mul::eval() const
 {
-	if ((level == 1) && (flags & status_flags::evaluated)) {
+	if (flags & status_flags::evaluated) {
 		GINAC_ASSERT(seq.size()>0);
 		GINAC_ASSERT(seq.size()>1 || !overall_coeff.is_equal(_ex1));
 		return *this;
 	}
 
-	const epvector evaled = evalchildren(level);
+	const epvector evaled = evalchildren();
 	if (unlikely(!evaled.empty())) {
 		// start over evaluating a new object
 		return dynallocate<mul>(std::move(evaled), overall_coeff);
diff --git a/ginac/mul.h b/ginac/mul.h
index 95eba3dc..e689ddf1 100644
--- a/ginac/mul.h
+++ b/ginac/mul.h
@@ -54,7 +54,7 @@ public:
 	int ldegree(const ex & s) const override;
 	ex coeff(const ex & s, int n = 1) const override;
 	bool has(const ex & other, unsigned options = 0) const override;
-	ex eval(int level=0) const override;
+	ex eval() const override;
 	ex evalf(int level=0) const override;
 	ex real_part() const override;
 	ex imag_part() const override;
diff --git a/ginac/ncmul.cpp b/ginac/ncmul.cpp
index c287a023..b43ec950 100644
--- a/ginac/ncmul.cpp
+++ b/ginac/ncmul.cpp
@@ -285,9 +285,8 @@ typedef std::vector<exvector> exvectorvector;
  *  - ncmul(...,c1,...,c2,...) -> *(c1,c2,ncmul(...))  (pull out commutative elements)
  *  - ncmul(x1,y1,x2,y2) -> *(ncmul(x1,x2),ncmul(y1,y2))  (collect elements of same type)
  *  - ncmul(x1,x2,x3,...) -> x::eval_ncmul(x1,x2,x3,...)
- *
- *  @param level cut-off in recursive evaluation */
-ex ncmul::eval(int level) const
+ */
+ex ncmul::eval() const
 {
 	// The following additional rule would be nice, but produces a recursion,
 	// which must be trapped by introducing a flag that the sub-ncmuls()
@@ -296,22 +295,20 @@ ex ncmul::eval(int level) const
 	//                      ncmul(ncmul(x1,x2,...),X,ncmul(y1,y2,...)
 	//                      (X noncommutative_composite)
 
-	if ((level==1) && (flags & status_flags::evaluated)) {
+	if (flags & status_flags::evaluated) {
 		return *this;
 	}
 
-	exvector evaledseq=evalchildren(level);
-
 	// ncmul(...,*(x1,x2),...,ncmul(x3,x4),...) ->
 	//     ncmul(...,x1,x2,...,x3,x4,...)  (associativity)
 	size_t factors = 0;
-	for (auto & it : evaledseq)
+	for (auto & it : seq)
 		factors += count_factors(it);
 	
 	exvector assocseq;
 	assocseq.reserve(factors);
-	make_flat_inserter mf(evaledseq, true);
-	for (auto & it : evaledseq) {
+	make_flat_inserter mf(seq, true);
+	for (auto & it : seq) {
 		ex factor = mf.handle_factor(it, 1);
 		append_factors(assocseq, factor);
 	}
@@ -476,7 +473,7 @@ ex ncmul::conjugate() const
 		--i;
 		ev.push_back(i->conjugate());
 	}
-	return dynallocate<ncmul>(std::move(ev)).eval();
+	return dynallocate<ncmul>(std::move(ev));
 }
 
 ex ncmul::real_part() const
diff --git a/ginac/ncmul.h b/ginac/ncmul.h
index 2233b8d7..0ed54f79 100644
--- a/ginac/ncmul.h
+++ b/ginac/ncmul.h
@@ -60,7 +60,7 @@ public:
 	int ldegree(const ex & s) const override;
 	ex expand(unsigned options=0) const override;
 	ex coeff(const ex & s, int n=1) const override;
-	ex eval(int level=0) const override;
+	ex eval() const override;
 	ex evalm() const override;
 	exvector get_free_indices() const override;
 	ex thiscontainer(const exvector & v) const override;
diff --git a/ginac/normal.cpp b/ginac/normal.cpp
index b2e8d109..7968b908 100644
--- a/ginac/normal.cpp
+++ b/ginac/normal.cpp
@@ -196,8 +196,8 @@ static void collect_symbols(const ex &e, sym_desc_vec &v)
  *  @param v  vector of sym_desc structs (filled in) */
 static void get_symbol_stats(const ex &a, const ex &b, sym_desc_vec &v)
 {
-	collect_symbols(a.eval(), v);   // eval() to expand assigned symbols
-	collect_symbols(b.eval(), v);
+	collect_symbols(a, v);
+	collect_symbols(b, v);
 	for (auto & it : v) {
 		int deg_a = a.degree(it.sym);
 		int deg_b = b.degree(it.sym);
diff --git a/ginac/numeric.cpp b/ginac/numeric.cpp
index 2bb92653..9b23214b 100644
--- a/ginac/numeric.cpp
+++ b/ginac/numeric.cpp
@@ -775,10 +775,8 @@ bool numeric::has(const ex &other, unsigned options) const
 
 
 /** Evaluation of numbers doesn't do anything at all. */
-ex numeric::eval(int level) const
+ex numeric::eval() const
 {
-	// Warning: if this is ever gonna do something, the ex ctors from all kinds
-	// of numbers should be checking for status_flags::evaluated.
 	return this->hold();
 }
 
diff --git a/ginac/numeric.h b/ginac/numeric.h
index 4d3135d5..a22209ed 100644
--- a/ginac/numeric.h
+++ b/ginac/numeric.h
@@ -103,7 +103,7 @@ public:
 	int ldegree(const ex & s) const override;
 	ex coeff(const ex & s, int n = 1) const override;
 	bool has(const ex &other, unsigned options = 0) const override;
-	ex eval(int level = 0) const override;
+	ex eval() const override;
 	ex evalf(int level = 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;
diff --git a/ginac/power.cpp b/ginac/power.cpp
index afe2f1ef..c376009b 100644
--- a/ginac/power.cpp
+++ b/ginac/power.cpp
@@ -373,42 +373,36 @@ ex power::coeff(const ex & s, int n) const
  *  - ^(*(x,y,z),c) -> *(x^c,y^c,z^c)  (if c integer)
  *  - ^(*(x,c1),c2) -> ^(x,c2)*c1^c2  (c1>0)
  *  - ^(*(x,c1),c2) -> ^(-x,c2)*c1^c2  (c1<0)
- *
- *  @param level cut-off in recursive evaluation */
-ex power::eval(int level) const
+ */
+ex power::eval() const
 {
-	if ((level==1) && (flags & status_flags::evaluated))
+	if (flags & status_flags::evaluated)
 		return *this;
-	else if (level == -max_recursion_level)
-		throw(std::runtime_error("max recursion level reached"));
-	
-	const ex & ebasis    = level==1 ? basis    : basis.eval(level-1);
-	const ex & eexponent = level==1 ? exponent : exponent.eval(level-1);
-	
+
 	const numeric *num_basis = nullptr;
 	const numeric *num_exponent = nullptr;
-	
-	if (is_exactly_a<numeric>(ebasis)) {
-		num_basis = &ex_to<numeric>(ebasis);
+
+	if (is_exactly_a<numeric>(basis)) {
+		num_basis = &ex_to<numeric>(basis);
 	}
-	if (is_exactly_a<numeric>(eexponent)) {
-		num_exponent = &ex_to<numeric>(eexponent);
+	if (is_exactly_a<numeric>(exponent)) {
+		num_exponent = &ex_to<numeric>(exponent);
 	}
 	
 	// ^(x,0) -> 1  (0^0 also handled here)
-	if (eexponent.is_zero()) {
-		if (ebasis.is_zero())
+	if (exponent.is_zero()) {
+		if (basis.is_zero())
 			throw (std::domain_error("power::eval(): pow(0,0) is undefined"));
 		else
 			return _ex1;
 	}
 	
 	// ^(x,1) -> x
-	if (eexponent.is_equal(_ex1))
-		return ebasis;
+	if (exponent.is_equal(_ex1))
+		return basis;
 
 	// ^(0,c1) -> 0 or exception  (depending on real value of c1)
-	if ( ebasis.is_zero() && num_exponent ) {
+	if (basis.is_zero() && num_exponent) {
 		if ((num_exponent->real()).is_zero())
 			throw (std::domain_error("power::eval(): pow(0,I) is undefined"));
 		else if ((num_exponent->real()).is_negative())
@@ -418,16 +412,16 @@ ex power::eval(int level) const
 	}
 
 	// ^(1,x) -> 1
-	if (ebasis.is_equal(_ex1))
+	if (basis.is_equal(_ex1))
 		return _ex1;
 
 	// power of a function calculated by separate rules defined for this function
-	if (is_exactly_a<function>(ebasis))
-		return ex_to<function>(ebasis).power(eexponent);
+	if (is_exactly_a<function>(basis))
+		return ex_to<function>(basis).power(exponent);
 
 	// Turn (x^c)^d into x^(c*d) in the case that x is positive and c is real.
-	if (is_exactly_a<power>(ebasis) && ebasis.op(0).info(info_flags::positive) && ebasis.op(1).info(info_flags::real))
-		return power(ebasis.op(0), ebasis.op(1) * eexponent);
+	if (is_exactly_a<power>(basis) && basis.op(0).info(info_flags::positive) && basis.op(1).info(info_flags::real))
+		return power(basis.op(0), basis.op(1) * exponent);
 
 	if ( num_exponent ) {
 
@@ -487,8 +481,8 @@ ex power::eval(int level) const
 		// ^(^(x,c1),c2) -> ^(x,c1*c2)
 		// (c1, c2 numeric(), c2 integer or -1 < c1 <= 1 or (c1=-1 and c2>0),
 		// case c1==1 should not happen, see below!)
-		if (is_exactly_a<power>(ebasis)) {
-			const power & sub_power = ex_to<power>(ebasis);
+		if (is_exactly_a<power>(basis)) {
+			const power & sub_power = ex_to<power>(basis);
 			const ex & sub_basis = sub_power.basis;
 			const ex & sub_exponent = sub_power.exponent;
 			if (is_exactly_a<numeric>(sub_exponent)) {
@@ -502,15 +496,15 @@ ex power::eval(int level) const
 		}
 	
 		// ^(*(x,y,z),c1) -> *(x^c1,y^c1,z^c1) (c1 integer)
-		if (num_exponent->is_integer() && is_exactly_a<mul>(ebasis)) {
-			return expand_mul(ex_to<mul>(ebasis), *num_exponent, 0);
+		if (num_exponent->is_integer() && is_exactly_a<mul>(basis)) {
+			return expand_mul(ex_to<mul>(basis), *num_exponent, 0);
 		}
 
 		// (2*x + 6*y)^(-4) -> 1/16*(x + 3*y)^(-4)
-		if (num_exponent->is_integer() && is_exactly_a<add>(ebasis)) {
-			numeric icont = ebasis.integer_content();
+		if (num_exponent->is_integer() && is_exactly_a<add>(basis)) {
+			numeric icont = basis.integer_content();
 			const numeric lead_coeff = 
-				ex_to<numeric>(ex_to<add>(ebasis).seq.begin()->coeff).div(icont);
+				ex_to<numeric>(ex_to<add>(basis).seq.begin()->coeff).div(icont);
 
 			const bool canonicalizable = lead_coeff.is_integer();
 			const bool unit_normal = lead_coeff.is_pos_integer();
@@ -518,7 +512,7 @@ ex power::eval(int level) const
 				icont = icont.mul(*_num_1_p);
 			
 			if (canonicalizable && (icont != *_num1_p)) {
-				const add& addref = ex_to<add>(ebasis);
+				const add& addref = ex_to<add>(basis);
 				add & addp = dynallocate<add>(addref);
 				addp.clearflag(status_flags::hash_calculated);
 				addp.overall_coeff = ex_to<numeric>(addp.overall_coeff).div_dyn(icont);
@@ -535,9 +529,9 @@ ex power::eval(int level) const
 
 		// ^(*(...,x;c1),c2) -> *(^(*(...,x;1),c2),c1^c2)  (c1, c2 numeric(), c1>0)
 		// ^(*(...,x;c1),c2) -> *(^(*(...,x;-1),c2),(-c1)^c2)  (c1, c2 numeric(), c1<0)
-		if (is_exactly_a<mul>(ebasis)) {
+		if (is_exactly_a<mul>(basis)) {
 			GINAC_ASSERT(!num_exponent->is_integer()); // should have been handled above
-			const mul & mulref = ex_to<mul>(ebasis);
+			const mul & mulref = ex_to<mul>(basis);
 			if (!mulref.overall_coeff.is_equal(_ex1)) {
 				const numeric & num_coeff = ex_to<numeric>(mulref.overall_coeff);
 				if (num_coeff.is_real()) {
@@ -563,17 +557,13 @@ ex power::eval(int level) const
 
 		// ^(nc,c1) -> ncmul(nc,nc,...) (c1 positive integer, unless nc is a matrix)
 		if (num_exponent->is_pos_integer() &&
-		    ebasis.return_type() != return_types::commutative &&
-		    !is_a<matrix>(ebasis)) {
-			return ncmul(exvector(num_exponent->to_int(), ebasis));
+		    basis.return_type() != return_types::commutative &&
+		    !is_a<matrix>(basis)) {
+			return ncmul(exvector(num_exponent->to_int(), basis));
 		}
 	}
-	
-	if (are_ex_trivially_equal(ebasis,basis) &&
-	    are_ex_trivially_equal(eexponent,exponent)) {
-		return this->hold();
-	}
-	return dynallocate<power>(ebasis, eexponent).setflag(status_flags::evaluated);
+
+	return this->hold();
 }
 
 ex power::evalf(int level) const
diff --git a/ginac/power.h b/ginac/power.h
index 1662ee03..ac85f722 100644
--- a/ginac/power.h
+++ b/ginac/power.h
@@ -59,7 +59,7 @@ public:
 	int degree(const ex & s) const override;
 	int ldegree(const ex & s) const override;
 	ex coeff(const ex & s, int n = 1) const override;
-	ex eval(int level=0) const override;
+	ex eval() const override;
 	ex evalf(int level=0) const override;
 	ex evalm() const override;
 	ex series(const relational & s, int order, unsigned options = 0) const override;
diff --git a/ginac/pseries.cpp b/ginac/pseries.cpp
index 08809fd1..31a92002 100644
--- a/ginac/pseries.cpp
+++ b/ginac/pseries.cpp
@@ -384,20 +384,18 @@ ex pseries::collect(const ex &s, bool distributed) const
 }
 
 /** Perform coefficient-wise automatic term rewriting rules in this class. */
-ex pseries::eval(int level) const
+ex pseries::eval() const
 {
-	if (level == 1)
-		return this->hold();
-	
-	if (level == -max_recursion_level)
-		throw (std::runtime_error("pseries::eval(): recursion limit exceeded"));
+	if (flags & status_flags::evaluated) {
+		return *this;
+	}
 	
 	// Construct a new series with evaluated coefficients
 	epvector new_seq;
 	new_seq.reserve(seq.size());
 	epvector::const_iterator it = seq.begin(), itend = seq.end();
 	while (it != itend) {
-		new_seq.push_back(expair(it->rest.eval(level-1), it->coeff));
+		new_seq.push_back(expair(it->rest, it->coeff));
 		++it;
 	}
 	return dynallocate<pseries>(relational(var,point), std::move(new_seq)).setflag(status_flags::evaluated);
diff --git a/ginac/pseries.h b/ginac/pseries.h
index 3a36e6d6..3670ff17 100644
--- a/ginac/pseries.h
+++ b/ginac/pseries.h
@@ -50,7 +50,7 @@ public:
 	int ldegree(const ex &s) const override;
 	ex coeff(const ex &s, int n = 1) const override;
 	ex collect(const ex &s, bool distributed = false) const override;
-	ex eval(int 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 subs(const exmap & m, unsigned options = 0) const override;
diff --git a/ginac/relational.cpp b/ginac/relational.cpp
index 479522cf..38d0baf7 100644
--- a/ginac/relational.cpp
+++ b/ginac/relational.cpp
@@ -176,17 +176,6 @@ ex relational::map(map_function & f) const
 		return *this;
 }
 
-ex relational::eval(int level) const
-{
-	if (level==1)
-		return this->hold();
-	
-	if (level == -max_recursion_level)
-		throw(std::runtime_error("max recursion level reached"));
-	
-	return dynallocate<relational>(lh.eval(level-1), rh.eval(level-1), o).setflag(status_flags::evaluated);
-}
-
 ex relational::subs(const exmap & m, unsigned options) const
 {
 	const ex & subsed_lh = lh.subs(m, options);
diff --git a/ginac/relational.h b/ginac/relational.h
index c8bf8b6d..0c9d65a1 100644
--- a/ginac/relational.h
+++ b/ginac/relational.h
@@ -58,7 +58,6 @@ public:
 	ex op(size_t i) const override;
 	ex map(map_function & f) const override;
 	ex subs(const exmap & m, unsigned options = 0) const override;
-	ex eval(int level=0) const override;
 
 	/** Save (a.k.a. serialize) object into archive. */
 	void archive(archive_node& n) const override;
diff --git a/ginac/structure.h b/ginac/structure.h
index 1301ad2b..657bf6b9 100644
--- a/ginac/structure.h
+++ b/ginac/structure.h
@@ -126,7 +126,7 @@ public:
 	// All these are just defaults that can be specialized by the user
 public:
 	// evaluation
-	ex eval(int level = 0) const override { return hold(); }
+	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:
diff --git a/ginac/symbol.h b/ginac/symbol.h
index 84320f27..157e4284 100644
--- a/ginac/symbol.h
+++ b/ginac/symbol.h
@@ -46,7 +46,7 @@ public:
 	// functions overriding virtual functions from base classes
 public:
 	bool info(unsigned inf) const override;
-	ex eval(int level = 0) const override { return *this; } // for performance reasons
+	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 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
diff --git a/ginsh/ginsh_parser.ypp b/ginsh/ginsh_parser.ypp
index 3a8f0621..96a864a8 100644
--- a/ginsh/ginsh_parser.ypp
+++ b/ginsh/ginsh_parser.ypp
@@ -242,7 +242,7 @@ exp	: T_NUMBER		{$$ = $1;}
 		if (i == assigned_symbol_table.end())
 			$$ = $1;
 		else
-			$$ = i->second.eval();
+			$$ = i->second;
 	}
 	| '\'' T_SYMBOL '\''	{$$ = $2;}
 	| T_LITERAL		{$$ = $1;}
@@ -331,7 +331,6 @@ static ex f_collect_common_factors(const exprseq &e) {return collect_common_fact
 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_eval1(const exprseq &e) {return e[0].eval();}
 static ex f_evalf1(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();}
@@ -414,12 +413,6 @@ static ex f_divide(const exprseq &e)
 		return fail();
 }
 
-static ex f_eval2(const exprseq &e)
-{
-	CHECK_ARG(1, numeric, eval);
-	return e[0].eval(ex_to<numeric>(e[1]).to_int());
-}
-
 static ex f_evalf2(const exprseq &e)
 {
 	CHECK_ARG(1, numeric, evalf);
@@ -618,8 +611,6 @@ static const fcn_init builtin_fcns[] = {
 	{"diff", f_diff2, 2},
 	{"diff", f_diff3, 3},
 	{"divide", f_divide, 2},
-	{"eval", f_eval1, 1},
-	{"eval", f_eval2, 2},
 	{"evalf", f_evalf1, 1},
 	{"evalf", f_evalf2, 2},
 	{"evalm", f_evalm, 1},
@@ -729,7 +720,7 @@ static void insert_fcns(const fcn_init *p)
 
 static ex f_ginac_function(const exprseq &es, int serial)
 {
-	return GiNaC::function(serial, es).eval(1);
+	return GiNaC::function(serial, es);
 }
 
 // All registered GiNaC functions