transform all subexpressions of a given type
evalindets( expr, atype, transformer, rest )
evalindets[flat]( expr, atype, transformer, rest )
evalindets[nocache]( expr, atype, transformer, rest )
evalindets[N]( expr, atype, preargs, transformer, rest )
anything; any Maple expression
type; any Maple type expression
anything; an expression (typically, a procedure) to be called on each subexpression processed
anything; (optional) expression sequence of extra arguments to be passed to transformer
integer; the number of arguments passed to the transformer before the subexpression
anything; expression sequence of N-1 arguments to be passed to the transformer before the subexpression
The command evalindets is a particular combination of calls to eval and indets that allows you to efficiently transform all subexpressions of a given type by some algorithm. It encapsulates a common "pattern" used in expression manipulation and transformation.
Each subexpression of type atype is transformed by the supplied transformer procedure. Then, each subexpression is replaced in the original expression, using eval, with the corresponding transformed expression.
If the flat option is supplied as an index to the evalindets command, then Maple will not recursively look inside any subexpressions of the given atype for further (nested) subexpressions of that type. This provides a hint to Maple that it can use a somewhat faster algorithm in this special case.
If the flat option is not supplied, then subexpressions of type atype at deeper levels of nesting are processed and replaced before subexpressions at shallower levels of nesting. This is illustrated in an example below.
By default, evalindets uses a cache to avoid repetitive type checking and repeated calls to transformer for multiple instances of the same subexpression (this cache is limited in size, so repeated calls may occur, but there is no guarantee that they will). The nocache option, specified as an index to the evalindets command, prevents the use of this cache, and guarantees that transformer will be called once for each instance of any common subexpression matching atype. Note that using the nocache option can dramatically lower the performance of evalindets on expressions containing many common subexpressions.
If evalindets is called with an integer index, N, then each subexpression to be processed by transformer will be passed as the N-th argument to transformer. The sequence of N-1 arguments of evalindets between atype and transformer will be passed as the first N-1 arguments to transformer.
A numeric index may be combined with the flat option, and they can be specified in either order.
This example changes every call to F to a call to H.
Shift all symbols by a constant of π.
Expand all products in an expression.
expr ≔ sin⁡x+y+x⁢x+1+x+1⁢x+2
Using evalindets, you can avoid expanding things you might not want expanded.
Optional arguments may be passed to the transformer.
expr ≔ sin⁡x+y+x⁢x+3+ⅇx+1⁢y+2
The following example demonstrates the use of evalindets[nocache]
In this first case, without nocache, the transformer function will be called at least once, and most likely only once, though this is not guaranteed, for each matching subexpression:
expr ≔ x2+3⁢x+f⁡x:
count ≔ 0:
evalindets(expr,symbol,proc(s) global count; count:=count+1; cat(s,count) end);
In this next case, with the nocache option, the transformer function is guaranteed to be called once for every instance of each matching subexpression:
evalindets['nocache'](expr,symbol,proc(s) global count; count:=count+1; cat(s,count) end);
The following example demonstrates the use of evalindets[N]
The evalindets[N] calling sequence is used when you want to pass additional arguments to the transformer function before the subexpression to be transformed:
expr ≔ f⁡x,y2+3⁢f⁡x,y+3;evalindets2⁡expr,specfunc⁡f,1,op
This calls op(1,x) for each subexpression, _x_ of type specfunc(f).
Without the [N] option, the alternative would be to introduce a procedure that takes a single argument x, and returns op(1,x):
This is less efficient because of the extra level of procedure calling. The subsindets command calls your procedure which calls op, instead of just calling op directly.
This example illustrates the remark above about the order in which subexpressions at various levels of nesting depth are processed. In it, we replace each integer in the expression that occurs inside a function call with a name that indicates the name of the closest enclosing function. This is done by using a second call to evalindets as the transformer.
expr ≔ 2+f⁡4,g⁡h⁡6
evalindets⁡expr,function,fn→evalindets⁡fn,integer,i→cat⁡i, in ,op⁡0,fn
2+f⁡4 in f,g⁡h⁡6 in h
This works because the outer call to evalindets processes h(6) (turning it into h(`6 in f`)) before it processes the calls to g or f; so when the transformer processes those calls, the integer 6 doesn't occur anymore.
The evalindets command was updated in Maple 2015.
The N parameter was introduced in Maple 2015.
The preargs parameter was updated in Maple 2015.
The nocache option was introduced in Maple 2015.
For more information on Maple 2015 changes, see Updates in Maple 2015.
Download Help Document
What kind of issue would you like to report? (Optional)