This is documentation for Mathematica 3, which was
based on an earlier version of the Wolfram Language.
 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 2x