Add the pair {x,y} to each element in a list of pairs:

Without Threaded, adding a list of scalars to the list of pairs would add a scalar value to each pair:

Create a rank-three array with dimensions {2,3,4}:

Add a 3×4 matrix to each of the two matrices in the array:

Create a rank-four array with dimensions {2,3,4,2}:

Adding a 3×4 matrix at the deepest threading level will fail because 3×4 differs from 4×2:

The matrix can be added at level 2 because the dimensions match:

Since the deepest array has rank 4, this is the same as threading at level -3:

Combining a scalar with a Threaded argument gives a Threaded result:

This preserves associativity:

When all of the arguments are Threaded objects, then the result is a single Threaded object:

Compare using Threaded with different positive levels for an array with depth 4:

Compare using Threaded with different negative levels for an array with depth 4:

Use Threaded with an arbitrary listable function:

Threaded arguments can appear in any order:

Use Threaded with SparseArray objects:

Add a vector to each row of a matrix:

Add a vector to each column of a matrix:

Zero the red channel and double the blue channel in 3D image data:

The same construct works for 2D image data:

Threaded[y,…] stays unevaluated unless inside a wrapping head with the Listable attribute:

If the operation cannot be performed, a message will be emitted and Threaded will stay unevaluated:

Default threading behavior of a listable function f with arrays a and b corresponds to Threaded[b,1]:

Thread the first level of b at the first level of a:

By default, Threaded[b] threads b at the lowest possible level that does not change the depth of a:

These two threading behaviors are different:

An array threaded at the lowest level is duplicated as a whole to create a sufficiently deep array for an operation:

When it is threaded at a higher level, individual entries are duplicated to fill out the array:

Threaded[b] is equivalent to Threaded[b,-1-1]:

This can also be expressed as Threaded[b,1-ArrayDepth[b]]:

For a listable function f, an array a and a vector v, the use of Threaded can be reproduced with Inner:

A transposition is needed for nondefault threading level:

Compare threading the first level of b at the first level of a, using both Threaded and an explicit Table:

Threading at nondefault levels can be also achieved by using two transpositions:

This permutation moves levels 3 and 4 of a to levels 1 and 2, leaving level 5 unchanged:

QuantityArray[mags,units] would correspond to Quantity[mags,Threaded[units]] if Quantity had the Listable attribute: