eval  evaluation

Calling Sequence


eval(e, x=a)


eval(e, eqns)


eval['recurse'](e, eqns)


eval(e)


eval(x, n)






Parameters


e



expression

x



usually a name but may be a general expression

a



expression

eqns



list or set of equations

n



positive integer





Description


•

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 obtaining 6.

•

You can enter the command eval using either the 1D or 2D calling sequence. For example, eval(x^3 + 3*x + 2, x=1) is equivalent to .

•

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 lefthand sides of the equations will be variable names being evaluated. However, if the lefthand side x of an equation is not a simple name, a syntactic substitution is 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 onelevel evaluation for local variables and parameters. Sometimes the user requires full evaluation or onelevel evaluation explicitly. For example, if and in a Maple session, what is the value of ? 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 onelevel 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 nlevels of evaluation of names.

•

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



Compatibility


•

The recurse option was introduced in Maple 18.



Thread Safety


•

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



Examples


Examples of using eval to evaluate at a 'point':
>


 (1) 
>


 (2) 
>


 (3) 
>


 (4) 
>


 (5) 
Example where eval will return a (correct) error instead of an incorrect answer:
>


 (6) 
>


>


 (7) 
Example using eval for inert integrals and derivatives.
>


 (8) 
>


 (9) 
>


 (10) 
>


 (11) 
Evaluate the variable a to a number of levels:
>


 (12) 
>


 (13) 
>


 (14) 
Default full evaluation.
>


 (15) 
Force full evaluation.
>


 (16) 
>


 (17) 
>


 (18) 
>


 (19) 
>


 (20) 
Recursive evaluation.
>


 (21) 
>


 (22) 


Comparing eval to subs



The eval command is different from the subs command.

 (23) 
 (24) 
 (25) 

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 the examples from above:

>

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

 (26) 
>

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

 (27) 
 (28) 
 (29) 


See Also


Eval, evala, evalb, evalc, evalf, evalhf, evaln, evalr, Extending Maple, limit, RealDomain, rtable_eval, subs, value

