transform all subexpressions of a given type
subsindets( expr, atype, transformer, rest )
subsindets[eval]( expr, atype, transformer, rest )
subsindets[flat]( expr, atype, transformer, rest )
subsindets[nocache]( expr, atype, transformer, rest )
subsindets[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; one more than 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 procedure subsindets is a particular combination of calls to subs 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 subs (or subs[eval], if the eval option is given), with the corresponding transformed expression.
If the flat option is supplied as an index to the subsindets 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, subsindets 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 subsindets 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 subsindets on expressions containing many common subexpressions.
If subsindets 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 subsindets between atype and transformer will be passed as the first N-1 arguments to transformer.
Any number of the options eval, flat, nocache, and N can be given in the index as an expression sequence, and they can be specified in any 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 subsindets, 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
expr ≔ a,b,3,4,c
The following example demonstrates the use of subsindets[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:
subsindets(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:
subsindets['nocache'](expr,symbol,proc(s) global count; count:=count+1; cat(s,count) end);
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 subsindets as the transformer.
expr ≔ 2+f⁡4,g⁡h⁡6
subsindets⁡expr,function,fn→subsindets⁡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 subsindets 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 subsindets command was updated in Maple 2015.
The N parameter was introduced in Maple 2015.
The eval and nocache options were introduced in Maple 2015.
For more information on Maple 2015 changes, see Updates in Maple 2015.
Download Help Document