# Applying Functions to Parts of Expressions

If you have a list of elements, it is often important to be able to apply a function separately to each of the elements. You can do this in

*Mathematica* using

Map.

This applies

separately to each element in a list.

Out[1]= | |

This defines a function which takes the first two elements from a list.

You can use

Map to apply

to each element of a list.

Out[3]= | |

Map[f,{a,b,...}] | apply f to each element in a list, giving |

Applying a function to each element in a list.

What

Map effectively does is to "wrap" the function

f around each element of the expression

expr. You can use

Map on any expression, not just a list.

This applies

to each element in the sum.

Out[4]= | |

This applies

Sqrt to each argument of

.

Out[5]= | |

Map applies

f to the first level of parts in

expr. You can use

MapAll to apply

f to

*all* the parts of

expr.

This defines a 2x2 matrix

.

Out[6]= | |

Map applies

to the first level of

, in this case the rows of the matrix.

Out[7]= | |

MapAll applies

at

*all* levels in

. If you look carefully at this expression, you will see an

wrapped around every part.

Out[8]= | |

In general, you can use level specifications as described in

"Levels in Expressions" to tell

Map to which parts of an expression to apply your function.

This applies

only to the parts of

at level 2.

Out[9]= | |

Setting the option

Heads->True wraps

around the head of each part, as well as its elements.

Out[10]= | |

Map[f,expr] or f/@expr | apply f to the first-level parts of expr |

MapAll[f,expr] or f//@expr | apply f to all parts of expr |

Map[f,expr,lev] | apply f to each part of expr at levels specified by lev |

Ways to apply a function to different parts of expressions.

Level specifications allow you to tell

Map to which levels of parts in an expression you want a function applied. With

MapAt, however, you can instead give an explicit list of parts where you want a function applied. You specify each part by giving its indices, as discussed in

"Parts of Expressions".

Out[11]= | |

This applies

to parts

and

.

Out[12]= | |

This gives a list of the positions at which

occurs in

.

Out[13]= | |

You can feed the list of positions you get from

Position directly into

MapAt.

Out[14]= | |

To avoid ambiguity, you must put each part specification in a list, even when it involves only one index.

Out[15]= | |

MapAt[f,expr,{part_{1},part_{2},...}] | apply f to specified parts of expr |

Applying a function to specific parts of an expression.

Out[16]= | |

This is the full form of

.

Out[17]//FullForm= |

| |

You can use

MapAt on any expression. Remember that parts are numbered on the basis of the full forms of expressions.

Out[18]= | |

MapIndexed[f,expr] | apply f to the elements of an expression, giving the part specification of each element as a second argument to f |

MapIndexed[f,expr,lev] | apply f to parts at specified levels, giving the list of indices for each part as a second argument to f |

Applying a function to parts and their indices.

This applies

to each element in a list, giving the index of the element as a second argument to

.

Out[19]= | |

This applies

to both levels in a matrix.

Out[20]= | |

Map allows you to apply a function of one argument to parts of an expression. Sometimes, however, you may instead want to apply a function of several arguments to corresponding parts of several different expressions. You can do this using

MapThread.

MapThread[f,{expr_{1},expr_{2},...}] | apply f to corresponding elements in each of the |

MapThread[f,{expr_{1},expr_{2},...},lev] | apply f to parts of the at the specified level |

Applying a function to several expressions at once.

This applies

to corresponding pairs of list elements.

Out[21]= | |

MapThread works with any number of expressions, so long as they have the same structure.

Out[22]= | |

Functions like

Map allow you to create expressions with parts modified. Sometimes you simply want to go through an expression, and apply a particular function to some parts of it, without building a new expression. A typical case is when the function you apply has certain "side effects", such as making assignments, or generating output.

Scan[f,expr] | evaluate f applied to each element of expr in turn |

Scan[f,expr,lev] | evaluate f applied to parts of expr on levels specified by lev |

Evaluating functions on parts of expressions.

Map constructs a new list in which

has been applied to each element of the list.

Out[23]= | |

Scan evaluates the result of applying a function to each element, but does not construct a new expression.

Scan visits the parts of an expression in a depth-first walk, with the leaves visited first.