Mathematica 9 is now available
THIS IS DOCUMENTATION FOR AN OBSOLETE PRODUCT.
SEE THE DOCUMENTATION CENTER FOR THE LATEST INFORMATION.
Wolfram Mathematica Documentation Center
DOCUMENTATION CENTER SEARCH
New to Mathematica? Find your learning path »
Mathematica > Systems Interfaces & Deployment > Parallel Computing > Data Parallelism > ParallelTable >
Mathematica > Core Language > Tuning & Debugging > Parallel Computing > Data Parallelism > ParallelTable >
BUILT-IN MATHEMATICA SYMBOLSee Also »|More About »

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.
MORE INFORMATION
  • 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.
EXAMPLESCLOSE ALL
Basic Examples   (5)
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]=
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:
Generalizations & Extensions   (1)
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:
Properties & Relations   (10)
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:
Possible Issues   (3)
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:
Neat Examples   (2)
Visualize the Mandelbrot set:
Calculate and display the Feigenbaum (or bifurcation) diagram of the logistics map:
New in 7 | Last modified in 8
Ask a question about this page  |  Suggest an improvement  |  Leave a message for the team
Format:   HTML  |  CDF