2.2.4 Applying Functions to Parts of ExpressionsIf 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]=
|
|
| Map[f, {a, b, ... }] | apply f to each element in a list, giving {f[a], f[b], ... } |
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. | |
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. | |
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. | |
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]=
|
|
| 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 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. | |
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. | |
In[15]:=
MapAt[f, {a, b, c, d}, {{2}, {3}}]
|
Out[15]=
|
|
MapAt[f, expr, { ,  , ... }] | apply f to specified parts of expr |
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. | |
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]=
|
|
| 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 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.
MapThread[f, { ,  , ... }] | apply f to corresponding elements in each of the  |
MapThread[f, { ,  , ... }, lev]
| | apply f to parts of the  at the specified level |
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.
| 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 f has been applied to each element of the list. | |
In[23]:=
Map[f, {a, b, c}]
|
Out[23]=
|
|
|
