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

ParallelTable

Updated In 8 Graphic
ParallelTable
generates in parallel a list of copies of expr.
ParallelTable
generates in parallel a list of the values of expr when i runs from 1 to .
ParallelTable
starts with .
ParallelTable
uses steps di.
ParallelTable
uses the successive values , , ....
ParallelTable
gives 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:
In[1]:=
Click for copyable input
Out[1]=
In[2]:=
Click for copyable input
Out[2]=
 
A table of the first 10 squares:
In[1]:=
Click for copyable input
Out[1]=
 
A table with i running from 0 to 20 in steps of 2:
In[1]:=
Click for copyable input
Out[1]=
 
Make a 4×3 matrix:
In[1]:=
Click for copyable input
Out[1]=
In[2]:=
Click for copyable input
Out[2]//MatrixForm=
 
Plot a table:
In[1]:=
Click for copyable input
Out[1]=
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:
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:
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:
New in 7 | Last modified in 8