[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
8.1 Functions and Variables for Evaluation |
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
The single quote operator '
prevents evaluation.
Applied to a symbol, the single quote prevents evaluation of the symbol.
Applied to a function call, the single quote prevents evaluation of the function call, although the arguments of the function are still evaluated (if evaluation is not otherwise prevented). The result is the noun form of the function call.
Applied to a parenthesized expression, the single quote prevents evaluation of
all symbols and function calls in the expression.
E.g., '(f(x))
means do not evaluate the expression f(x)
.
'f(x)
(with the single quote applied to f
instead of f(x)
)
means return the noun form of f
applied to [x]
.
The single quote does not prevent simplification.
When the global flag noundisp
is true
, nouns display with a single
quote. This switch is always true
when displaying function definitions.
See also the quote-quote operator ''
and nouns
.
Examples:
Applied to a symbol, the single quote prevents evaluation of the symbol.
(%i1) aa: 1024; (%o1) 1024 (%i2) aa^2; (%o2) 1048576 (%i3) 'aa^2; 2 (%o3) aa (%i4) ''%; (%o4) 1048576
Applied to a function call, the single quote prevents evaluation of the function call. The result is the noun form of the function call.
(%i1) x0: 5; (%o1) 5 (%i2) x1: 7; (%o2) 7 (%i3) integrate (x^2, x, x0, x1); 218 (%o3) --- 3 (%i4) 'integrate (x^2, x, x0, x1); 7 / [ 2 (%o4) I x dx ] / 5 (%i5) %, nouns; 218 (%o5) --- 3
Applied to a parenthesized expression, the single quote prevents evaluation of all symbols and function calls in the expression.
(%i1) aa: 1024; (%o1) 1024 (%i2) bb: 19; (%o2) 19 (%i3) sqrt(aa) + bb; (%o3) 51 (%i4) '(sqrt(aa) + bb); (%o4) bb + sqrt(aa) (%i5) ''%; (%o5) 51
The single quote does not prevent simplification.
(%i1) sin (17 * %pi) + cos (17 * %pi); (%o1) - 1 (%i2) '(sin (17 * %pi) + cos (17 * %pi)); (%o2) - 1
Maxima considers floating point operations by its in-built mathematical functions to be a simplification.
(%i1) sin(1.0); (%o1) .8414709848078965 (%i2) '(sin(1.0)); (%o2) .8414709848078965
Categories: Evaluation · Operators
The quote-quote operator ''
(two single quote marks) modifies
evaluation in input expressions.
Applied to a general expression expr, quote-quote causes the value of expr to be substituted for expr in the input expression.
Applied to the operator of an expression, quote-quote changes the operator from a noun to a verb (if it is not already a verb).
The quote-quote operator is applied by the input parser; it is not stored as
part of a parsed input expression. The quote-quote operator is always applied
as soon as it is parsed, and cannot be quoted. Thus quote-quote causes
evaluation when evaluation is otherwise suppressed, such as in function
definitions, lambda expressions, and expressions quoted by single quote
'
.
Quote-quote is recognized by batch
and load
.
See also the single-quote operator '
and nouns
.
Examples:
Applied to a general expression expr, quote-quote causes the value of expr to be substituted for expr in the input expression.
(%i1) expand ((a + b)^3); 3 2 2 3 (%o1) b + 3 a b + 3 a b + a (%i2) [_, ''_]; 3 3 2 2 3 (%o2) [expand((b + a) ), b + 3 a b + 3 a b + a ] (%i3) [%i1, ''%i1]; 3 3 2 2 3 (%o3) [expand((b + a) ), b + 3 a b + 3 a b + a ] (%i4) [aa : cc, bb : dd, cc : 17, dd : 29]; (%o4) [cc, dd, 17, 29] (%i5) foo_1 (x) := aa - bb * x; (%o5) foo_1(x) := aa - bb x (%i6) foo_1 (10); (%o6) cc - 10 dd (%i7) ''%; (%o7) - 273 (%i8) ''(foo_1 (10)); (%o8) - 273 (%i9) foo_2 (x) := ''aa - ''bb * x; (%o9) foo_2(x) := cc - dd x (%i10) foo_2 (10); (%o10) - 273 (%i11) [x0 : x1, x1 : x2, x2 : x3]; (%o11) [x1, x2, x3] (%i12) x0; (%o12) x1 (%i13) ''x0; (%o13) x2 (%i14) '' ''x0; (%o14) x3
Applied to the operator of an expression, quote-quote changes the operator from a noun to a verb (if it is not already a verb).
(%i1) declare (foo, noun); (%o1) done (%i2) foo (x) := x - 1729; (%o2) ''foo(x) := x - 1729 (%i3) foo (100); (%o3) foo(100) (%i4) ''foo (100); (%o4) - 1629
The quote-quote operator is applied by the input parser; it is not stored as part of a parsed input expression.
(%i1) [aa : bb, cc : dd, bb : 1234, dd : 5678]; (%o1) [bb, dd, 1234, 5678] (%i2) aa + cc; (%o2) dd + bb (%i3) display (_, op (_), args (_)); _ = cc + aa op(cc + aa) = + args(cc + aa) = [cc, aa] (%o3) done (%i4) ''(aa + cc); (%o4) 6912 (%i5) display (_, op (_), args (_)); _ = dd + bb op(dd + bb) = + args(dd + bb) = [dd, bb] (%o5) done
Quote-quote causes evaluation when evaluation is otherwise suppressed, such as
in function definitions, lambda expressions, and expressions quoted by single
quote '
.
(%i1) foo_1a (x) := ''(integrate (log (x), x)); (%o1) foo_1a(x) := x log(x) - x (%i2) foo_1b (x) := integrate (log (x), x); (%o2) foo_1b(x) := integrate(log(x), x) (%i3) dispfun (foo_1a, foo_1b); (%t3) foo_1a(x) := x log(x) - x (%t4) foo_1b(x) := integrate(log(x), x) (%o4) [%t3, %t4] (%i5) integrate (log (x), x); (%o5) x log(x) - x (%i6) foo_2a (x) := ''%; (%o6) foo_2a(x) := x log(x) - x (%i7) foo_2b (x) := %; (%o7) foo_2b(x) := % (%i8) dispfun (foo_2a, foo_2b); (%t8) foo_2a(x) := x log(x) - x (%t9) foo_2b(x) := % (%o9) [%t7, %t8] (%i10) F : lambda ([u], diff (sin (u), u)); (%o10) lambda([u], diff(sin(u), u)) (%i11) G : lambda ([u], ''(diff (sin (u), u))); (%o11) lambda([u], cos(u)) (%i12) '(sum (a[k], k, 1, 3) + sum (b[k], k, 1, 3)); (%o12) sum(b , k, 1, 3) + sum(a , k, 1, 3) k k (%i13) '(''(sum (a[k], k, 1, 3)) + ''(sum (b[k], k, 1, 3))); (%o13) b + a + b + a + b + a 3 3 2 2 1 1
Categories: Evaluation · Operators
Evaluates the expression expr in the environment specified by the
arguments arg_1, …, arg_n. The arguments are switches
(Boolean flags), assignments, equations, and functions. ev
returns the
result (another expression) of the evaluation.
The evaluation is carried out in steps, as follows.
simp
causes expr to be simplified regardless of the setting of the
switch simp
which inhibits simplification if false
.
noeval
suppresses the evaluation phase of ev
(see step (4) below).
This is useful in conjunction with the other switches and in causing
expr to be resimplified without being reevaluated.
nouns
causes the evaluation of noun forms (typically unevaluated
functions such as 'integrate
or 'diff
) in expr.
expand
causes expansion.
expand (m, n)
causes expansion, setting the values of
maxposex
and maxnegex
to m and n respectively.
detout
causes any matrix inverses computed in expr to have their
determinant kept outside of the inverse rather than dividing through
each element.
diff
causes all differentiations indicated in expr to be performed.
derivlist (x, y, z, ...)
causes only differentiations
with respect to the indicated variables. See also derivlist
.
risch
causes integrals in expr to be evaluated using the Risch
algorithm. See risch
.
The standard integration routine is invoked
when using the special symbol nouns
.
float
causes non-integral rational numbers to be converted to floating
point.
numer
causes some mathematical functions (including exponentiation)
with numerical arguments to be evaluated in floating point. It causes
variables in expr which have been given numervals to be replaced by
their values. It also sets the float
switch on.
pred
causes predicates (expressions which evaluate to true
or
false
) to be evaluated.
eval
causes an extra post-evaluation of expr to occur.
(See step (5) below.)
eval
may occur multiple times. For each instance of eval
, the
expression is evaluated again.
A
where A
is an atom declared to be an evaluation flag
evflag
causes A
to be bound to true
during the evaluation
of expr.
V: expression
(or alternately V=expression
) causes V
to be
bound to the value of expression
during the evaluation of expr.
Note that if V
is a Maxima option, then expression
is used for
its value during the evaluation of expr. If more than one argument to
ev
is of this type then the binding is done in parallel. If V
is
a non-atomic expression then a substitution rather than a binding is performed.
F
where F
, a function name, has been declared to be an evaluation
function evfun
causes F
to be applied to expr.
sum
,
cause evaluation of occurrences
of those names in expr as though they were verbs.
F(x)
) may be defined
locally for the purpose of this evaluation of expr by giving
F(x) := expression
as an argument to ev
.
ev
. This permits a list of equations to be
given (e.g. [X=1, Y=A**2]
) or a list of names of equations (e.g.,
[%t1, %t2]
where %t1
and %t2
are equations) such as that
returned by solve
.
The arguments of ev
may be given in any order with the exception of
substitution equations which are handled in sequence, left to right, and
evaluation functions which are composed, e.g., ev (expr, ratsimp,
realpart)
is handled as realpart (ratsimp (expr))
.
The simp
,
numer
,
and float
switches may also be set
locally in a block, or globally in Maxima so that they will remain in effect
until being reset.
If expr is a canonical rational expression (CRE), then the expression
returned by ev
is also a CRE, provided the numer
and float
switches are not both true
.
%
(as in
%i2
in the example below), so this step simply retrieves the expression
named by the label, so that ev
may work on it.
noeval
) and simplified according to the arguments. Note that any
function calls in expr will be carried out after the variables in it are
evaluated and that ev(F(x))
thus may behave like F(ev(x))
.
eval
in the arguments, steps (3) and (4) are
repeated.
Examples:
(%i1) sin(x) + cos(y) + (w+1)^2 + 'diff (sin(w), w); d 2 (%o1) cos(y) + sin(x) + -- (sin(w)) + (w + 1) dw (%i2) ev (%, numer, expand, diff, x=2, y=1); 2 (%o2) cos(w) + w + 2 w + 2.449599732693821
An alternate top level syntax has been provided for ev
, whereby one
may just type in its arguments, without the ev()
. That is, one may
write simply
expr, arg_1, ..., arg_n
This is not permitted as part of another expression, e.g., in functions, blocks, etc.
Notice the parallel binding process in the following example.
(%i3) programmode: false; (%o3) false (%i4) x+y, x: a+y, y: 2; (%o4) y + a + 2 (%i5) 2*x - 3*y = 3$ (%i6) -3*x + 2*y = -4$ (%i7) solve ([%o5, %o6]); Solution 1 (%t7) y = - - 5 6 (%t8) x = - 5 (%o8) [[%t7, %t8]] (%i8) %o6, %o8; (%o8) - 4 = - 4 (%i9) x + 1/x > gamma (1/2); 1 (%o9) x + - > sqrt(%pi) x (%i10) %, numer, x=1/2; (%o10) 2.5 > 1.772453850905516 (%i11) %, pred; (%o11) true
Categories: Evaluation
As an argument in a call to ev (expr)
, eval
causes an extra
evaluation of expr. See ev
.
Example:
(%i1) [a:b,b:c,c:d,d:e]; (%o1) [b, c, d, e] (%i2) a; (%o2) b (%i3) ev(a); (%o3) c (%i4) ev(a),eval; (%o4) e (%i5) a,eval,eval; (%o5) e
Categories: Evaluation flags
When a symbol x has the evflag
property, the expressions
ev(expr, x)
and expr, x
(at the
interactive prompt) are equivalent to ev(expr, x = true)
.
That is, x is bound to true
while expr is evaluated.
The expression declare(x, evflag)
gives the evflag
property
to the variable x.
The flags which have the evflag
property by default are the following:
algebraic cauchysum demoivre dotscrules %emode %enumer exponentialize exptisolate factorflag float halfangles infeval isolate_wrt_times keepfloat letrat listarith logabs logarc logexpand lognegint m1pbranch numer_pbranch programmode radexpand ratalgdenom ratfac ratmx ratsimpexpons simp simpproduct simpsum sumexpand trigexpand
Examples:
(%i1) sin (1/2); 1 (%o1) sin(-) 2 (%i2) sin (1/2), float; (%o2) 0.479425538604203 (%i3) sin (1/2), float=true; (%o3) 0.479425538604203 (%i4) simp : false; (%o4) false (%i5) 1 + 1; (%o5) 1 + 1 (%i6) 1 + 1, simp; (%o6) 2 (%i7) simp : true; (%o7) true (%i8) sum (1/k^2, k, 1, inf); inf ==== \ 1 (%o8) > -- / 2 ==== k k = 1 (%i9) sum (1/k^2, k, 1, inf), simpsum; 2 %pi (%o9) ---- 6 (%i10) declare (aa, evflag); (%o10) done (%i11) if aa = true then YES else NO; (%o11) NO (%i12) if aa = true then YES else NO, aa; (%o12) YES
Categories: Evaluation flags · Simplification flags and variables
When a function F has the evfun
property, the expressions
ev(expr, F)
and expr, F
(at the
interactive prompt) are equivalent to F(ev(expr))
.
If two or more evfun
functions F, G, etc., are specified,
the functions are applied in the order that they are specified.
The expression declare(F, evfun)
gives the evfun
property
to the function F. The functions which have the evfun
property by
default are the following:
bfloat factor fullratsimp logcontract polarform radcan ratexpand ratsimp rectform rootscontract trigexpand trigreduce
Examples:
(%i1) x^3 - 1; 3 (%o1) x - 1 (%i2) x^3 - 1, factor; 2 (%o2) (x - 1) (x + x + 1) (%i3) factor (x^3 - 1); 2 (%o3) (x - 1) (x + x + 1) (%i4) cos(4 * x) / sin(x)^4; cos(4 x) (%o4) -------- 4 sin (x) (%i5) cos(4 * x) / sin(x)^4, trigexpand; 4 2 2 4 sin (x) - 6 cos (x) sin (x) + cos (x) (%o5) ------------------------------------- 4 sin (x) (%i6) cos(4 * x) / sin(x)^4, trigexpand, ratexpand; 2 4 6 cos (x) cos (x) (%o6) - --------- + ------- + 1 2 4 sin (x) sin (x) (%i7) ratexpand (trigexpand (cos(4 * x) / sin(x)^4)); 2 4 6 cos (x) cos (x) (%o7) - --------- + ------- + 1 2 4 sin (x) sin (x) (%i8) declare ([F, G], evfun); (%o8) done (%i9) (aa : bb, bb : cc, cc : dd); (%o9) dd (%i10) aa; (%o10) bb (%i11) aa, F; (%o11) F(cc) (%i12) F (aa); (%o12) F(bb) (%i13) F (ev (aa)); (%o13) F(cc) (%i14) aa, F, G; (%o14) G(F(cc)) (%i15) G (F (ev (aa))); (%o15) G(F(cc))
Categories: Evaluation flags
Enables "infinite evaluation" mode. ev
repeatedly evaluates an
expression until it stops changing. To prevent a variable, say X
, from
being evaluated away in this mode, simply include X='X
as an argument to
ev
. Of course expressions such as ev (X, X=X+1, infeval)
will
generate an infinite loop.
Categories: Evaluation flags
noeval
suppresses the evaluation phase of ev
.
This is useful in
conjunction with other switches and in causing expressions
to be resimplified without being reevaluated.
Categories: Evaluation flags
nouns
is an evflag
.
When used as an option to the ev
command, nouns
converts all "noun" forms occurring in the expression
being ev
'd to "verbs", i.e., evaluates them. See also
noun
,
nounify
,
verb
, and verbify
.
Categories: Evaluation flags · Nouns and verbs
As an argument in a call to ev (expr)
, pred
causes
predicates (expressions which evaluate to true
or false
) to be
evaluated. See ev
.
Example:
(%i1) 1<2; (%o1) 1 < 2 (%i2) 1<2,pred; (%o2) true
Categories: Evaluation flags
[ << ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
This document was generated by Oliver Kullmann on May, 18 2013 using texi2html 1.76.