This is documentation for Mathematica 8, which was
based on an earlier version of the Wolfram Language.
View current documentation (Version 11.1)

Thread

Thread
"threads" f over any lists that appear in args.
Thread
threads f over any objects with head h that appear in args.
Thread
threads f over objects with head h that appear in the first n args.
  • Functions with attribute Listable are automatically threaded over lists.
  • All the elements in the specified args whose heads are h must be of the same length.
  • Arguments that do not have head h are copied as many times as there are elements in the arguments that do have head h. »
  • Thread specifies arguments using the standard sequence specification:
Allall elements
Noneno elements
nelements 1 through n
-nlast n elements
{n}element n only
{m,n}elements m through n inclusive
{m,n,s}elements m through n in steps of s
Convert equations for lists to lists of equations:
Apply a function to both sides of an equation:
In[1]:=
Click for copyable input
Out[1]=
In[2]:=
Click for copyable input
Out[2]=
In[3]:=
Click for copyable input
Out[3]=
 
Convert equations for lists to lists of equations:
In[1]:=
Click for copyable input
Out[1]=
 
Apply a function to both sides of an equation:
In[1]:=
Click for copyable input
Out[1]=
By default, thread over all arguments:
Do not thread at all:
Thread over the first two arguments only:
Thread over the last two arguments only:
Thread over argument 2 only:
Thread over arguments 2 through 4:
Thread over every other argument:
By default, thread over lists:
By default, does not thread over heads other than List:
Thread with respect to Plus:
Elements that are not lists are repeated:
Build a list of rules:
Equate coefficients in a polynomial equation:
Alternatively, use SolveAlways:
Form pairs with a constant second element:
Functions with attribute Listable are threaded automatically over lists:
MapThread works like Thread, but takes the function and arguments separately:
The function to thread over can be List as well:
In this case, the result is the same as a transposition:
Thread evaluates the whole expression before threading:
MapThread takes the function and its arguments separately:
Suppressing evaluation has a similar effect:
New in 1