# `misc`::`maprec`

Map a function to subexpressions of an expression

MuPAD® notebooks will be removed in a future release. Use MATLAB® live scripts instead.

MATLAB live scripts support most MuPAD functionality, though there are some differences. For more information, see Convert MuPAD Notebooks to MATLAB Live Scripts.

## Syntax

```misc::maprec(`ex`, `selector = funci, …`, <`PreMap | PostMap`>, <NoOperators>, <Unsimplified>)
```

## Description

`misc::maprec(ex, selector=funci)` maps the function `funci` to all subexpressions of the expression `ex` that satisfy a given criterion (defined by `selector`) and replaces each selected subexpression `s` by `funci(s)`.

Several different functions may be mapped to subexpressions satisfying different selection criteria.

```misc::maprec(ex, selector1 = funci1, …, selectorn = funcin)``` does two steps: it tests whether `ex` meets a selection criterion defined by some selector `selector_k` (and, if yes, replaces `ex` by `funci_k(ex)`); and it applies itself recursively to all operands of `ex`. The order of these steps is determined by the options `PreMap` and `PostMap`.

Selectors are applied from left to right; if the expression meets some selection criterion, no further selectors are tried.

`selector` can have two forms. It can be a set {t1, …, tn}. Here a subexpression `s` of `ex` is selected if type(s1) is one of the types t1, …, tn. If it is not a set, a subexpression `s` of `ex` is selected if `p`(s) returns `TRUE`. As every MuPAD® object may be applied as a function to `s`, `p` may be of any type in the latter case.

In order not to select a subexpression, the selector need not return `FALSE`; it suffices that it does not return `TRUE`.

If neither the option `PreMap` nor the option `PostMap` is given, then `PreMap` is used.

Use a `misc::breakmap` command inside `funci` in order to stop the recursive mapping. See the help page of `misc::breakmap` for an example.

### Note

Only subexpressions of domain type `DOM_ARRAY`, `DOM_EXPR`, `DOM_LIST`, `DOM_SET`, and `DOM_TABLE` are mapped recursively, as well as domain elements of a domain `T` for which a slot `T::enableMaprec` exists and equals `TRUE`; a slot `T::map` working properly must then exist, too. To subexpressions of other types, `selector` is applied, but `misc::maprec` is not mapped to their operands. (This is to avoid unwanted substitutions.) If you want to recurse on them, either add an `enableMaprec`-slot, or use a `selector` that selects such subexpressions, and make `funci` initiate another recursive mapping.

`misc::maprec` is overloadable. If the domain of a subexpression has a method `"maprec"`, then this method is called with the subexpression and the other arguments of the call.

### Note

The subexpression is replaced by the result, but `misc::maprec` is not mapped to its operands; such recursive mapping must be done by the domain method if desired.

### Note

The operators of expressions (`op(expression, 0)`) are also mapped recursively like all the other operands. Use `NoOperators` to switch this off.

## Examples

### Example 1

In the following example every integer of the given expression `a+3+4` is substituted by the value 10. Since `10(n)` returns `10` for every integer `n`, it suffices to write `10` instead of `n -> 10` here.

`misc::maprec(hold(a+3+4), {DOM_INT} = 10)`
` `

In the example above, we used `hold` to suppress the evaluation of the expression because otherwise `a+3+4` is evaluated to `a+7` and we get the result:

`misc::maprec(a+3+4, {DOM_INT} = 10)`
` `

The simplification of the resulting `10 + 10` to `20` can be avoided by using the option `Unsimplified`:

`misc::maprec(hold(a+3+4), {DOM_INT} = 10, Unsimplified)`
` `

### Example 2

Now we give an example where the `selector` is a function. We want to eleminate all the prime numbers from an expression.

`misc::maprec(hold(_plus)(i \$ i=1..20), isprime= null(), PostMap)`
` `

Here `isprime` returns `TRUE` for every prime number between 1 and 20. Every prime number between 1 and 20 is replaced by null() (since `null()(p)` gives `null()`) which means the above call computes the sum of all non-prime numbers between 1 and 20.

### Example 3

Normally, `misc::maprec` recurses also into the operators of subexpressions. This may be unwanted in many cases:

`misc::maprec(a+b, {DOM_IDENT}= (x -> x.1))`
` `

We just wanted to replace the summands, but not the operator. Using the option `NoOperators` helps:

`misc::maprec(a+b, {DOM_IDENT}= (x -> x.1), NoOperators)`
` `

## Parameters

 `ex` Any MuPAD object `selector` Any MuPAD object `funci` Any MuPAD object

## Options

 `PreMap` For each subexpressions `s` of `ex`, the selector is applied to it after visiting all of its subexpressions; `s` may have changed at that time due to substitutions in the subexpressions. `PostMap` For each subexpressions `s` of `ex`, the selector is applied to it before visiting its subexpressions. If `s` is selected by `selector`, it is replaced by `funci(s)`, and `misc::maprec` is not recursively applied to the operands of `funci(s)`; otherwise, `misc::maprec` is recursively applied to the operands of `s`. `NoOperators` The selector is not applied to the operator of `ex`. `Unsimplified` The resulting expressions are not further simplified.

## Return Values

`misc::maprec` may return any MuPAD object.

`ex`