The most common use of the eval function is to evaluate an expression e at a given point x=a.  For example, eval(x^2+3*x+2,x=1) evaluates the polynomial x^2+3*x+2 at the point $x=1$ obtaining 6.

You can enter the command eval using either the 1-D or 2-D calling sequence. For example, eval(x^3 + 3*x + 2, x=1) is equivalent to $\genfrac{}{}{0ex}{}{\left(x^3+3x+2\right)}{\phantom{x=1}}|\genfrac{}{}{0ex}{}{\phantom{\left(x^3+3x+2\right)}}{x=1}$.

In the second and third calling sequences, where eqns is a set or list of equations, the expression e is evaluated at all the given points (or expressions) simultaneously.  If the index 'recurse' is given (the third calling sequence above), the evaluation is repeated until either the result does not change or an infinite loop is detected in the evaluation.

Usually, the left-hand sides of the equations will be variable names being evaluated.  However, if the left-hand side x of an equation is not a simple name, a syntactic substitution may be attempted which has the same limitations as with subs.

Since eval does pointwise evaluation, eval cannot be used to evaluate an expression at a singularity. Use limit instead.

The eval command knows how to correctly evaluate derivatives, integrals, piecewise function definitions, etc. whereas the subs command in comparison makes substitutions which may not make sense mathematically. If there are symbolic dependencies between the expression and the point at which it should be evaluated that are considered "unsafe", eval will return unevaluated. This knowledge is coded in the Maple library in the Maple procedures `eval/diff`, `eval/int`, `eval/piecewise`, etc. The user may teach Maple how to evaluate a function as follows. Given a function foo(y), the call eval(foo(y),x=a) will result in `eval/foo`(foo(y),x=a) being called if the user has defined `eval/foo` to be a Maple procedure.

The two remaining calling sequences of the eval function are used to perform explicit evaluation of a variable or expression. The meaning of evaluation in these cases is different from the previous calling sequences. The default evaluation rules in Maple are full evaluation for global variables, and one-level evaluation for local variables and parameters.  Sometimes the user requires full evaluation or one-level evaluation explicitly. For example, if  $x≔y$ and $y≔1$ in a Maple session, what is the value of $x$ ? In an interactive session where x and y are global variables, x would evaluate to 1 and we would say that x is "fully evaluated". For one-level evaluation, we would use the command eval(x, 1) which would in this case yield y. However, inside a Maple procedure, if x is a local variable or a parameter, then x evaluates to y and we would say x evaluated "one level". For parameters, this is only relevant when the variable being passed as a parameter is not a global variable, since it would then be fully evaluated before being passed to the procedure. For local variables and parameters, full evaluation is obtained with eval(x), yielding 1 in this example.

The call eval(e) means the expression e is fully evaluated up to two delayed evaluations (see uneval). This means that each name in e will be evaluated to its value, and the value will be evaluated recursively, and each function call in e will be executed with its parameters evaluated, but not beyond two levels of delayed evaluations.

The call eval(x, 1) means evaluate the name x one level. That is, the value assigned to the name x is returned without further evaluation.  More generally, eval(x, n) yields n-levels of evaluation of names.

Evaluation to n levels (n>1) is most useful for expressions that are still just names after n-1 levels of evaluation.  The eval(x, n) call returns the result of evaluating the name found at level n-1 to one level.

While evaluation to n levels can be applied directly to expressions other than names, the outcome can vary greatly depending on how the actual structure of the expression interacts with various automatic simplifications.

Applying eval to mutable container objects like tables, rtables, and modules does not map over the elements.  Use map(eval,M) to evaluate elements in an object, M.

When called from within a procedure being executed in the evalhf environment, eval forces an evaluation to take place outside of evalhf. Everything within the argument sequence to eval is evaluated in symbolic mode (that is, using symbols, integers, and software floating-point values). The result of the evaluation is converted back to a hardware float or array thereof. If this is not possible, an exception is raised.

The eval command is thread safe as of Maple 15, provided that evaluating the given expression is itself thread safe.

For more information on thread safety, see index/threadsafe.

$\mathrm{poly}≔x^3+3x+2$

$\mathrm{poly}≔x^3+3x+2$

$\mathrm{eval}\left(\mathrm{poly}\,x=1\right)$

$6$

$\mathrm{poly}≔xy+3z+2$

$\mathrm{poly}≔xy+3z+2$

$\mathrm{eval}\left(\mathrm{poly}\,\left[x=2\,y=3\,z=t\right]\right)$

$3t+8$

$\mathrm{eval}\left(\mathrm{int}\left(\sin \left(x\right)\,x\right)\,x=1\right)$

$-\cos \left(1\right)$

$\mathrm{expr}≔\frac{\sin \left(x\right)}{x}$

$\mathrm{expr}≔\frac{\sin \left(x\right)}{x}$

$\mathrm{eval}\left(\mathrm{expr}\,x=0\right)$

Error, numeric exception: division by zero

$\mathrm{limit}\left(\mathrm{expr}\,x=0\right)$

$1$

$\mathrm{integral}≔\mathrm{Int}\left(f\left(t\,a\right)\,t=a..x\right)$

$\mathrm{integral}≔{\int }_a^{x}f\left(t\,a\right)\ⅆt$

$\mathrm{eval}\left(\mathrm{integral}\,\left\{a=1\,t=0\right\}\right)$

${\int }_1^{x}f\left(t\,1\right)\ⅆt$

$\mathrm{der}≔\mathrm{diff}\left(f\left(x\right)\,x\right)+f\left(x\right)$

$\mathrm{der}≔\frac{\ⅆ}{\ⅆx}f\left(x\right)+f\left(x\right)$

$\mathrm{eval}\left(\mathrm{der}\,x=0\right)$

$\genfrac{}{}{0ex}{}{\left(\frac{\ⅆ}{\ⅆx}f\left(x\right)\right)}{\phantom{\left\{x=0\right\}}}|\genfrac{}{}{0ex}{}{\phantom{\left(\frac{\ⅆ}{\ⅆx}f\left(x\right)\right)}}{\left\{x=0\right\}}+f\left(0\right)$

$a≔b$

$a≔b$

$b≔c$

$b≔c$

$c≔x+1$

$c≔x+1$

$a$

$x+1$

$\mathrm{eval}\left(a\right)$

$x+1$

$\mathrm{eval}\left(a\,1\right)$

$b$

$\mathrm{eval}\left(a\,2\right)$

$c$

$\mathrm{eval}\left(a\,3\right)$

$x+1$

$\mathrm{eval}\left(a\,4\right)$

$x+1$

$\mathrm{eval}\left(u+v+w\,\left[u=v\,v=w\,w=1\right]\right)$

$v+w+1$

$\mathrm{eval}\left['\mathrm{recurse}'\right]\left(u+v+w\,\left[u=v\,v=w\,w=1\right]\right)$

$3$

The eval command is different from the subs command.

expr := sin(x)/cos(x);

$\mathrm{expr}≔\frac{\sin \left(x\right)}{\cos \left(x\right)}$

subs(x = 0, expr);

$\frac{\sin \left(0\right)}{\cos \left(0\right)}$

eval(expr, x = 0);

$0$

The eval and subs commands treat the evaluation of inert integrals differently: the subs command only inserts the given value(s) into the expression, but does not perform any evaluation in the case of inert expressions.

Using examples from the previous section:

a := 'a':

subs({a = 1, t = 0}, integral);

$\mathrm{Int}\left(f\left(0\,1\right)\,0=1..x\right)$

eval(integral, {t=0, a=1});

${\int }_1^{x}f\left(t\,1\right)\ⅆt$

Substituting x=0 into the derivative defined above leads to a meaningless expression. Evaluating the derivative at x=0, however, gives the unevaluated derivative we saw above.

subs(x=0, der);

$\mathrm{diff}\left(f\left(0\right)\,0\right)+f\left(0\right)$

eval(der, x=0);

$\genfrac{}{}{0ex}{}{\left(\frac{\ⅆ}{\ⅆx}f\left(x\right)\right)}{\phantom{\left\{x=0\right\}}}|\genfrac{}{}{0ex}{}{\phantom{\left(\frac{\ⅆ}{\ⅆx}f\left(x\right)\right)}}{\left\{x=0\right\}}+f\left(0\right)$

The eval command was updated in Maple 2016; see Advanced Math.

The recurse option was introduced in Maple 18.

For more information on Maple 18 changes, see Updates in Maple 18.