[proxy] web.archive.org — ← back | site home | direct (HTTPS) ↗ | proxy home | ◑ dark◐ light

Map (/@)—Wolfram Language Documentation

Map

Map[f,expr] or f/@expr

applies f to each element on the first level in expr.

Map[f,expr,levelspec]

applies f to parts of expr specified by levelspec.

Map[f]

represents an operator form of Map that can be applied to an expression.

Details and Options

  • Map uses standard level specifications:
  • nlevels 1 through n
    Infinitylevels 1 through Infinity
    {n}level n only
    {n1,n2}levels n1 through n2
  • The default value for levelspec in Map is {1}.
  • A positive level n consists of all parts of expr specified by n indices.
  • A negative level -n consists of all parts of expr with depth n.
  • Level –1 consists of numbers, symbols, and other objects that do not have subparts.
  • Level 0 corresponds to the whole expression.
  • With the option setting Heads->True, Map includes heads of expressions and their parts.
  • Map always effectively constructs a complete new expression and then evaluates it.
  • If expr is an Association object, Map[f,expr] applies f to the values in the association.
  • If expr is a SparseArray object, Map[f,expr] applies f to the values or subarrays that appear in expr.
  • Map[f][expr] is equivalent to Map[f,expr].

Examples

open allclose all

Basic Examples  (8)

Alternative input form:

Use explicit pure functions:

Map at top level:

Map at level 2:

Map at levels 1 and 2:

Use a map operator:

Map a function over values in Association:

Map at the second level of a nested Association:

Map at several levels in an Association:

Scope  (6)

Level Specifications  (6)

Map at level 1 (default):

Map down to level 2:

Map at level 2:

Map on levels 0 through 2:

Map down to level 3:

Map on all levels, starting at level 1:

Map also at level 0:

Negative levels:

Positive and negative levels can be mixed:

Different heads at each level:

Include heads in the levels specified:

Generalizations & Extensions  (4)

Map can be used on expressions with any head:

The function can be mapped onto the heads as well:

Functions with attribute Listable are mapped automatically:

Map can be used on sparse arrays:

Options  (1)

Heads  (1)

By default, the function is not mapped onto the heads:

Applications  (4)

Reverse all sublists:

Add the same vector to every vector in a list:

Frame integers that are prime:

Supply additional constant arguments by using a pure function:

Properties & Relations  (5)

Leaves are visited before roots:

A function of several arguments can be mapped with MapThread:

MapIndexed passes the index of an element to the mapped function:

MapAll is equivalent to a specific level specification in Map:

Scan does the same as Map, but without returning a result:

Possible Issues  (1)

Map by default starts at level 1, so does not apply the function to the whole expression:

Neat Examples  (1)

Show nesting structure of an expression: