WOLFRAM

Wolfram Language & System Documentation Center

ParallelCases[{e1,e2,…},pattern]

gives a list of the ei that match the pattern, in parallel.

ParallelCases[expr,pattern,levelspec]

gives a list of all parts of expr on levels specified by levelspec that match the pattern.

Details and Options
Details and Options Details and Options
Examples  
Basic Examples  
Scope  
Options  
DistributedContexts  
Method  
ProgressReporting  
Properties & Relations  
Possible Issues  
See Also
Related Guides
History
Cite this Page

ParallelCases

ParallelCases[{e1,e2,…},pattern]

gives a list of the ei that match the pattern, in parallel.

ParallelCases[expr,pattern,levelspec]

gives a list of all parts of expr on levels specified by levelspec that match the pattern.

Details and Options

  • ParallelCases is a parallel version of Cases.
  • ParallelCases will give the same results as Cases, except for side effects during the computation.
  • Parallelize[Cases[data,pattern]] is equivalent to ParallelCases[data,pattern].
  • The following options can be given:
  • Method Automaticgranularity of parallelization
    DistributedContexts $DistributedContextscontexts used to distribute symbols to parallel computations
    ProgressReporting $ProgressReportingwhether to report the progress of the computation
  • The Method option specifies the parallelization method to use. Possible settings include:
  • "CoarsestGrained"break the computation into as many pieces as there are available kernels
    "FinestGrained"break the computation into the smallest possible subunits
    "EvaluationsPerKernel"->ebreak the computation into at most e pieces per kernel
    "ItemsPerEvaluation"->mbreak the computation into evaluations of at most m subunits each
    Automaticcompromise between overhead and load balancing
  • Method->"CoarsestGrained" is suitable for computations involving many subunits, all of which take the same amount of time. It minimizes overhead but does not provide any load balancing.
  • Method->"FinestGrained" is suitable for computations involving few subunits whose evaluations take different amounts of time. It leads to higher overhead but maximizes load balancing.
  • The DistributedContexts option specifies which symbols appearing in expr have their definitions automatically distributed to all available kernels before the computation.
  • The default value is DistributedContexts:>$DistributedContexts with $DistributedContexts:=$Context, which distributes definitions of all symbols in the current context but does not distribute definitions of symbols from packages.
  • The ProgressReporting option specifies whether to report the progress of the parallel computation.
  • The default value is ProgressReporting:>$ProgressReporting.

Examples

open all close all

Basic Examples  (1)

Find cases that explicitly match integers:

Wolfram Language code: ParallelCases[{1, 1, f[a], 2, 3, y, f[8], 9, f[10]}, _Integer]

Find cases that do not match integers:

Wolfram Language code: ParallelCases[{1, 1, f[a], 2, 3, y, f[8], 9, f[10]}, Except[_Integer]]

Scope  (1)

Pick out cases of integers down to level 2:

Wolfram Language code: ParallelCases[{{1, 4, a, 0}, {b, 3, 2, 2}, {c, c, 5, 5}}, _Integer, 2]

Options  (5)

DistributedContexts  (2)

By default, definitions in the current context are distributed automatically:

Wolfram Language code: test[i_] := PrimeQ[2 ^ i - 1]
Wolfram Language code: ParallelCases[Range[9000, 10000], _ ? test]

Do not distribute any definitions of functions:

Wolfram Language code: test2[i_] := PrimeQ[2 ^ i - 1]
Wolfram Language code: ParallelSelect[Range[9000, 10000], _ ? test2, DistributedContexts -> None]

Method  (1)

Break the computation into as many subparts as there are kernels:

Wolfram Language code: ParallelCases[Range[32], n_ ? PrimeQ :> {n, $KernelID}, Method -> "CoarsestGrained"]

Schedule each evaluation by itself:

Wolfram Language code: ParallelCases[Range[32], n_ ? PrimeQ :> {n, $KernelID}, Method -> "FinestGrained"]

ProgressReporting  (2)

Do not show a temporary progress report:

Wolfram Language code: res = ParallelCases[Range[9000, 12000], n_ /; PrimeQ[2 ^ n - 1], Method -> "FinestGrained", ProgressReporting -> False]

Use Method"FinestGrained" for the most accurate progress report:

Wolfram Language code: res = ParallelCases[Range[9000, 12000], n_ /; PrimeQ[2 ^ n - 1], Method -> "FinestGrained", ProgressReporting -> True]

Properties & Relations  (1)

Parallelize[Cases[…]] is equivalent to ParallelCases[…]:

Wolfram Language code: Parallelize[Cases[Range[20], _ ? PrimeQ]]
Wolfram Language code: ParallelCases[Range[20], _ ? PrimeQ]

Possible Issues  (1)

The optional length argument of Cases cannot be parallelized:

Wolfram Language code: ParallelCases[Sqrt[Range[100]], _Integer, {1}, 3]
Wolfram Research (2025), ParallelCases, Wolfram Language function, https://reference.wolfram.com/language/ref/ParallelCases.html.

Text

Wolfram Research (2025), ParallelCases, Wolfram Language function, https://reference.wolfram.com/language/ref/ParallelCases.html.

CMS

Wolfram Language. 2025. "ParallelCases." Wolfram Language & System Documentation Center. Wolfram Research. https://reference.wolfram.com/language/ref/ParallelCases.html.

APA

Wolfram Language. (2025). ParallelCases. Wolfram Language & System Documentation Center. Retrieved from https://reference.wolfram.com/language/ref/ParallelCases.html

BibTeX

@misc{reference.wolfram_2026_parallelcases, author="Wolfram Research", title="{ParallelCases}", year="2025", howpublished="\url{https://reference.wolfram.com/language/ref/ParallelCases.html}", note=[Accessed: 13-June-2026]}

BibLaTeX

@online{reference.wolfram_2026_parallelcases, organization={Wolfram Research}, title={ParallelCases}, year={2025}, url={https://reference.wolfram.com/language/ref/ParallelCases.html}, note=[Accessed: 13-June-2026]}