Note: Use only in the MuPAD Notebook Interface. This functionality does not run in MATLAB. |
Operations on symbolic expressions often involve finding subexpressions and replacing them with values or with other subexpressions. MuPAD^{®} provides the following functions for this task:
evalAt
replaces
specified objects in the expression tree with the specified values
or subexpressions, and then evaluates the expression. This function
replaces only entire branches of expression trees. It cannot replace
a part of the branch, for example, two terms in the sum of three terms:
a*(b + c) | b = d, a*(b + c) | b + c = d, a*(b + c + 1) | b + c = d
evalAt
replaces
only free identifiers:
int(f(x), x = 0..1) + f(x) | x = 100
subs
replaces
specified objects in the expression tree with the specified values
or subexpressions. This function cannot replace a part of the branch
in the expression tree:
subs(a*(b + c), b + c = d), subs(a*(b + c + 1), b + c = d)
After substitution, subs
does
not evaluate the resulting expression (although it can simplify the
expression). You can enforce evaluation of the modified subexpressions
by using the EvalChanges
option:
subs(ln(x), x = E), subs(ln(x), x = E, EvalChanges)
subs
replaces
both free and dependent identifiers. In some cases, replacing dependent
identifiers can cause invalid results:
subs(int(f(x), x = 0..1) + f(x), x = 100)
subsex
analyzes
associative system operators and can replace part of the branch in
the expression tree:
subsex(a*(b + c), b + c = d), subsex(a*(b + c + 1), b + c = d)
subsex
does
not evaluate the resulting expression:
subsex(ln(x + a + 1), x + a = E - 1)
Use eval
to
evaluate results returned by subsex
:
eval(%)
subsop
replaces
only entire branches in the expression tree of an expression, the
same way as subs
.
When using subsop
,
you must know the position (index) of the branch inside the expression
in internal order that might differ from the output order used to
represent the expression on screen. To find the internal index of
a particular subexpression, use the op
function:
ex := sin(a*x + b) + cos(a*x + b): op(ex);
op(ex, 2);
op(ex, [2, 1]);
op(ex, [2, 1, 2]);
op(ex, [2, 1, 2, 1])
Now you can use subsop
to
replace the parameter a
with some value. For example,
replace it with the value 3:
subsop(ex, [2, 1, 2, 1] = 3)
prog::find
helps
you find all occurrences of a specific value in the expression. For
example, find all sums in this expression:
ex := (x + 1)/(x^2 + 2*x - 2) - 1/x + 1/(x + 1): pos := [prog::find(ex, hold(_plus))]; map(pos, p -> op(ex, p)); map(pos, p -> op(ex, p[1..-2]))
You also can find all subexpressions of a particular type (for
example, all Bessel functions or all branches not containing x
),
execute some code for these subexressions and replace them with the
return value of that code. For this task, use the misc::maprec
function.
Suppose you want to rewrite all terms that contain the sine
and tangent functions in terms of cosine functions. (In this example,
do not use sin(x)^{2} =
1 - cos(x)^{2} and
similar identities.) First, create the functions sin2cos
and tan2cos
that
rewrite expressions in terms of the cosine function. These functions
access the operands of the sine and tangent functions using op(ex)
:
sin2cos := ex -> cos(op(ex) - PI/2): tan2cos := ex -> cos(op(ex) - PI/2)/cos(op(ex)):
Now you can use these functions when replacing all occurrences
of sine and tangent functions in an expression. To replace subexpressions
of the original expression, use misc::maprec
. The misc::maprec
function uses the syntax misc::maprec(expression,
selector = replacement)
, where:
expression
is the original expression
(subexpressions of which you want to replace).
selector
is the selection criterion
(for example, a set of types of
subexpressions that you want to replace).
replacement
is the procedure that
you want to use to replace subexpressions of the original expression.
MuPAD applies misc::maprec
recursively
to all subexpressions of the original expression. For example, in
this call misc::maprec
replaces
all occurrences of sin
and tan
,
including the sine function in tan(sin(x))
:
misc::maprec(sin(x) + tan(x^2) - tan(sin(x)), {"sin"} = sin2cos, {"tan"} = tan2cos)
Besides data types or types of expressions, such as "sin"
or "tan"
,
you can use procedures to represent selection criteria in misc::maprec
. In this
example, the selection criterion of misc::maprec
is the procedure ex
-> bool(freeIndets(ex) = {})
that excludes free identifiers
and selects all constants of an expression. Using the procedure f
as
a replacement
, misc::maprec
replaces all nonrational
constants of an expression with new identifiers:
f := proc(x) option remember; begin if testtype(x, Type::Rational) then x else genident(); end_if; end: misc::maprec(a = 5*b + PI*sqrt(2)*c + PI, (ex -> bool(freeIndets(ex) = {})) = f)
option remember
in f
ensures
that constants appearing multiple times always get the same identifier.
Moreover, you can access the remember table of the procedure f
and
select which substitutions you want to make:
select([op(op(f,5))], _not@bool)