This is documentation for Mathematica 8, which was
based on an earlier version of the Wolfram Language.

# ParallelTable

 ParallelTablegenerates in parallel a list of copies of expr. ParallelTablegenerates in parallel a list of the values of expr when i runs from 1 to . ParallelTablestarts with . ParallelTableuses steps di. ParallelTable uses the successive values , , .... ParallelTablegives a nested list. The list associated with i is outermost.
• ParallelTable is a parallel version of Table which automatically distributes different evaluations of expr among different kernels and processors.
• ParallelTable will give the same results as Table, except for side effects during the computation.
• The DistributedContexts option for ParallelTable specifies which symbols appearing in expr have their definitions automatically distributed to all available kernels before the computation.
ParallelTable works like Table, but in parallel:
A table of the first 10 squares:
A table with i running from 0 to 20 in steps of 2:
Make a 4×3 matrix:
Plot a table:
ParallelTable works like Table, but in parallel:
 Out[1]=
 Out[2]=

A table of the first 10 squares:
 Out[1]=

A table with i running from 0 to 20 in steps of 2:
 Out[1]=

Make a 4×3 matrix:
 Out[1]=
 Out[2]//MatrixForm=

Plot a table:
 Out[1]=
 Scope   (5)
The index in the table can run backward:
Make a triangular array:
Make a 3x2x4 array, or tensor:
Iterate over an existing list:
Make an array from existing lists:
The table index can have symbolic values:
 Options   (11)
Break the computation into the smallest possible subunits:
Break the computation into as many pieces as there are available kernels:
Break the computation into at most 2 evaluations per kernel for the entire job:
Break the computation into evaluations of at most 5 elements each:
The default option setting balances evaluation size and number of evaluations:
Calculations with vastly differing runtimes should be parallelized as finely as possible:
A large number of simple calculations should be distributed into as few batches as possible:
By default, definitions in the current context are distributed automatically:
Do not distribute any definitions of functions:
Distribute definitions for all symbols in all contexts appearing in a parallel computation:
Distribute only definitions in the given contexts:
Restore the value of the DistributedContexts option to its default:
 Applications   (6)
Solve and plot a differential equation for many initial conditions and animate the results:
Explore different parameter values for the sine-Gordon equation in two spatial dimensions:
Apply different algorithms to the same set of data:
Apply a list of different filters to the same image and display the result:
Or apply a list of effects:
Generate 10 frames from an animation and save them to individual files:
Run several batches in parallel:
Each run returns one frame which can be used for checking the correctness:
Remove the generated files:
Tabulate histograms of word lengths in various languages:
Show the results in a grid:
Quickly show the evaluation of several nontrivial cellular automata:
Parallelization happens along the outermost (first) index:
Using multiple iteration specifications is equivalent to nesting Table functions:
ParallelDo evaluates the same sequence of expressions as ParallelTable:
ParallelSum effectively applies Plus to results from ParallelTable:
ParallelArray iterates over successive integers:
Map applies a function to successive elements in a list:
Table can substitute successive elements in a list into an expression:
ParallelTable iterating over a given list is equivalent to ParallelCombine:
ParallelTable can be implemented with WaitAll and ParallelSubmit:
Parallelization at the innermost level of a multidimensional table:
Functions defined interactively are automatically distributed to all kernels when needed:
Distribute definitions manually and disable automatic distribution:
For functions from a package, use ParallelNeeds rather than DistributeDefinitions:
A function used that is not known on the parallel kernels may lead to sequential evaluation:
Define the function on all parallel kernels:
The function is now evaluated on the parallel kernels:
Definitions of functions in the current context are distributed automatically:
Definitions from contexts other than the default context are not distributed automatically:
Use DistributeDefinitions to distribute such definitions:
Alternatively, set the DistributedContexts option to include all contexts:
Trivial operations may take longer when parallelized:
Visualize the Mandelbrot set:
Calculate and display the Feigenbaum (or bifurcation) diagram of the logistics map: