**2.2.4 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 f separately to each element in a list.
In[1]:= **Map[f, {a, b, c}]**

Out[1]=

This defines a function which takes the first two elements from a list.
In[2]:= **take2[list_] := Take[list, 2]**

You can use Map to apply take2 to each element of a list.
In[3]:= **Map[take2, {{1, 3, 4}, {5, 6, 7}, {2, 1, 6, 6}}]**

Out[3]=

Applying a function to each element in a list.

What Map[f,expr] 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 f to each element in the sum.
In[4]:= **Map[f, a + b + c]**

Out[4]=

This applies Sqrt to each argument ofÂ g.
In[5]:= **Map[Sqrt, g[x^2, x^3]]**

Out[5]=

Map[f,expr] applies f to the first level of parts in expr. You can use MapAll[f,expr] to apply f to all the parts of expr.

This defines a matrix m

.
In[6]:= **m = {{a, b}, {c, d}}**

Out[6]=

Map applies f to the first level of m, in this case the rows of the matrix.
In[7]:= **Map[f, m]**

Out[7]=

MapAll applies f at all levels in m. If you look carefully at this expression, you will see an f wrapped around every part.
In[8]:= **MapAll[f, m]**

Out[8]=

In general, you can use level specifications as described in SectionÂ 2.1.7 to tell Map to which parts of an expression to apply your function.

This applies f only to the parts of m at level 2.
In[9]:= **Map[f, m, {2}]**

Out[9]=

Setting the option Heads->True wraps f around the head of each part, as well as its elements.
In[10]:= **Map[f, m, Heads->True]**

Out[10]=

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 Section 2.1.4.

Here is a

matrix.
In[11]:= **mm = {{a, b, c}, {b, c, d}}**

Out[11]=

This applies f to parts {1,2} and {2,3}.
In[12]:= **MapAt[f, mm, {{1, 2}, {2, 3}}]**

Out[12]=

This gives a list of the positions at which b occurs in mm.
In[13]:= **Position[mm, b]**

Out[13]=

You can feed the list of positions you get from Position directly into MapAt.
In[14]:= **MapAt[f, mm, %]**

Out[14]=

To avoid ambiguity, you must put each part specification in a list, even when it involves only one index.
In[15]:= **MapAt[f, {a, b, c, d}, {{2}, {3}}]**

Out[15]=

Applying a function to specific parts of an expression.

Here is an expression.
In[16]:= **t = 1 + (3 + x)^2 / x**

Out[16]=

This is the full form of t.
In[17]:= **FullForm[ t ]**

Out[17]//FullForm=

You can use MapAt on any expression. Remember that parts are numbered on the basis of the full forms of expressions.
In[18]:= **MapAt[f, t, {{2, 1, 1}, {2, 2}}]**

Out[18]=

Applying a function to parts and their indices.

This applies f to each element in a list, giving the index of the element as a second argument to f.
In[19]:= **MapIndexed[f, {a, b, c}]**

Out[19]=

This applies f to both levels in a matrix.
In[20]:= **MapIndexed[f, {{a, b}, {c, d}}, 2]**

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.

Applying a function to several expressions at once.

This applies f to corresponding pairs of list elements.
In[21]:= **MapThread[f, {{a, b, c}, {ap, bp, cp}}]**

Out[21]=

MapThread works with any number of expressions, so long as they have the same structure.
In[22]:= **MapThread[f, {{a, b}, {ap, bp}, {app, bpp}}]**

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.

Evaluating functions on parts of expressions.

Map constructs a new list in which f has been applied to each element of the list.
In[23]:= **Map[f, {a, b, c}]**

Out[23]=

Scan evaluates the result of applying a function to each element, but does not construct a new expression.
In[24]:= **Scan[Print, {a, b, c}]**

a

b

c

Scan visits the parts of an expression in a depth-first walk, with the leaves visited first.
In[25]:= **Scan[Print, 1 + x^2, Infinity]**

1

x

2

2

x