Built-in Mathematica Symbol

Thread

Thread[f[args]]
"threads" f over any lists that appear in args.

Thread[f[args], h]
threads f over any objects with head h that appear in args.

Thread[f[args], h, n]
threads f over objects with head h that appear in the first n args.

MORE INFORMATION

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:

	All	all elements
	None	no elements
	n	elements 1 through n
	-n	last n elements
	{n}	element n only
	{m,n}	elements m through n inclusive
	{m,n,s}	elements m through n in steps of s

EXAMPLES

CLOSE ALL

Basic Examples (3)

Convert equations for lists to lists of equations:

Apply a function to both sides of an equation:

Convert equations for lists to lists of equations:

In[1]:=

Out[1]=

Apply a function to both sides of an equation:

In[1]:=

Out[1]=

Scope (9)

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:

Generalizations & Extensions (1)

Elements that are not lists are repeated:

Applications (3)

Build a list of rules:

Equate coefficients in a polynomial equation:

Alternatively, use SolveAlways:

Form pairs with a constant second element:

Properties & Relations (3)

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:

Possible Issues (1)

Thread evaluates the whole expression before threading:

MapThread takes the function and its arguments separately:

Suppressing evaluation has a similar effect: