WOLFRAM

Wolfram Language & System Documentation Center
Wolfram Language Home Page »

Compile
✖
Compile

✖
Compile[{x1,x2,…},expr]

creates a compiled function that evaluates expr assuming numerical values of the xi.

✖
Compile[{{x1,t1},…},expr]

assumes that xi is of a type that matches ti.

✖
Compile[{{x1,t1,n1},…},expr]

assumes that xi is a rank ni array of objects, each of a type that matches ti.

✖
Compile[vars,expr,{{p1,pt1},…}]

assumes that subexpressions in expr that match pi are of types that match pti.

Details and Options

  • The types handled by Compile are:
  • _Integermachine‐size integer
    _Realmachine‐precision approximate real number (default)
    _Complexmachine‐precision approximate complex number
    True | Falselogical variable
  • Nested lists given as input to a compiled function must be full arrays of numbers.
  • Compile handles numerical functions, matrix operations, procedural programming constructs, list manipulation functions, and functional programming constructs, etc.
  • Compile generates a CompiledFunction object.
  • Compiled code does not handle numerical precision and local variables in the same way as ordinary Wolfram Language code.
  • If a compiled function cannot be evaluated with particular arguments using compiled code, ordinary Wolfram Language code is used instead.
  • Ordinary Wolfram Language code can be called from within compiled code. Results obtained from the Wolfram Language code are assumed to be approximate real numbers, unless specified otherwise by the third argument of Compile.
  • The number of times and the order in which objects are evaluated by Compile may be different from ordinary Wolfram Language code.
  • Compile has attribute HoldAll, and does not by default do any evaluation before compilation.
  • You can use Compile[…,Evaluate[expr]] to specify that expr should be evaluated symbolically before compilation.
  • The following options can be given:
  • CompilationOptions Automaticoptions for the compilation process
    CompilationTarget $CompilationTargetthe target runtime for code generation
    Parallelization Automaticparallel controls for compiled function execution
    RuntimeAttributes {}evaluation attributes for the compiled function
    RuntimeOptions Automaticruntime options for the compiled function

Examples

open allclose all

Basic Examples  (1)Summary of the most common use cases

Compile the function Sin[x]+x^2-1/(1-x) for machine real x:

In[1]:=1
✖
https://wolfram.com/xid/0giqxe-f055ga
Out[1]=1

The CompiledFunction evaluates with machine numbers:

In[2]:=2
✖
https://wolfram.com/xid/0giqxe-e25ts
Out[2]=2

Plot the compiled function:

In[3]:=3
✖
https://wolfram.com/xid/0giqxe-xk5gw
Out[3]=3

Scope  (1)Survey of the scope of standard use cases

Compile the function to take Newton iterations for and identify the nearest root:

In[1]:=1
✖
https://wolfram.com/xid/0giqxe-cadgg9
Out[1]=1

Plot the basins of attraction for the three roots:

In[2]:=2
✖
https://wolfram.com/xid/0giqxe-cuwxq5
Out[2]=2

Options  (9)Common values & functionality for each option

CompilationOptions  (1)

The default setting of Automatic generates more efficient code by avoiding computing the same result more than once:

In[1]:=1
✖
https://wolfram.com/xid/0giqxe-xgnv2
Out[1]=1

When the optimization level is reduced, less efficient code is generated:

In[2]:=2
✖
https://wolfram.com/xid/0giqxe-hoh
Out[2]=2

CompilationTarget  (2)

This generates C code and links it back in for execution:

In[1]:=1
✖
https://wolfram.com/xid/0giqxe-gpxxqy
Out[1]=1

This is a larger example that demonstrates the speed advantages of C code generation:

In[1]:=1
✖
https://wolfram.com/xid/0giqxe-d6blo1
Out[1]=1

The default operation runs more slowly:

In[2]:=2
✖
https://wolfram.com/xid/0giqxe-e8pv6d
Out[2]=2

Parallelization  (2)

Listable compiled functions can execute in parallel using threads:

In[1]:=1
✖
https://wolfram.com/xid/0giqxe-hv8mo4
Out[1]=1

This shows the operation running sequentially:

In[2]:=2
✖
https://wolfram.com/xid/0giqxe-g974g6
Out[2]=2

Typically, $ProcessorCount is used to determine how many threads to be used:

In[3]:=3
✖
https://wolfram.com/xid/0giqxe-bo7f4z
Out[3]=3

You can combine parallel operations with C code generation to get even faster operation:

In[1]:=1
✖
https://wolfram.com/xid/0giqxe-ga9ju1
Out[1]=1

RuntimeAttributes  (3)

This creates a listable compiled function:

In[1]:=1
✖
https://wolfram.com/xid/0giqxe-bid3j6
Out[1]=1

It operates on a single input in normal fashion:

In[2]:=2
✖
https://wolfram.com/xid/0giqxe-eiexky
Out[2]=2

When the arguments include a list that does not match the input specification, it threads over that argument:

In[3]:=3
✖
https://wolfram.com/xid/0giqxe-h7ile
Out[3]=3

If there is a branch, listability needs a function to be defined, as shown below using Function:

In[1]:=1
✖
https://wolfram.com/xid/0giqxe-cz9qk
Out[1]=1

A listable compiled function is equivalent but executes faster:

In[2]:=2
✖
https://wolfram.com/xid/0giqxe-dttx1n
Out[2]=2

A listable compiled function can run in parallel, giving an acceleration on multicore machines:

In[3]:=3
✖
https://wolfram.com/xid/0giqxe-di8bmb
Out[3]=3

Using the listable attribute is typically faster than invoking CompiledFunction many times:

In[1]:=1
✖
https://wolfram.com/xid/0giqxe-dgcinn
In[2]:=2
✖
https://wolfram.com/xid/0giqxe-jpskmh
Out[2]=2
In[3]:=3
✖
https://wolfram.com/xid/0giqxe-lccazo
Out[3]=3

Using parallelization can give an even greater speedup:

In[4]:=4
✖
https://wolfram.com/xid/0giqxe-cc4p48
In[5]:=5
✖
https://wolfram.com/xid/0giqxe-h9kc53
Out[5]=5

The results are identical:

In[6]:=6
✖
https://wolfram.com/xid/0giqxe-cvkl2v
Out[6]=6

A detailed plot of the basins of attraction for Newton's method for :

In[7]:=7
✖
https://wolfram.com/xid/0giqxe-c08wwp
Out[7]=7

RuntimeOptions  (1)

Typically, integer arithmetic overflow is caught and the computation switches to use bignums:

In[1]:=1
✖
https://wolfram.com/xid/0giqxe-jw23o
Out[1]=1

Turning off overflow checking makes for faster execution, but the result can be incorrect:

In[2]:=2
✖
https://wolfram.com/xid/0giqxe-hro72
Out[2]=2

Possible Issues  (1)Common pitfalls and unexpected behavior

With the default setting for RuntimeOptions intermediate overflow may be missed:

In[1]:=1
✖
https://wolfram.com/xid/0giqxe-f5ssdn
Out[1]=1

With the "Quality" setting, intermediate terms are tested for overflow:

In[2]:=2
✖
https://wolfram.com/xid/0giqxe-ei2zij
Out[2]=2

Neat Examples  (1)Surprising or curious use cases

Perlin noise is a common algorithm used to generate procedural textures:

In[1]:=1
✖
https://wolfram.com/xid/0giqxe-f1enoy

This defines the parameters to the Perlin noise function and uses the Perlin function to generate a landscape procedural texture:

In[2]:=2
✖
https://wolfram.com/xid/0giqxe-c937y
Out[2]=2

The same noise function, with different parameters and color set, can simulate wood grain:

In[3]:=3
✖
https://wolfram.com/xid/0giqxe-boqarr
Out[3]=3

You can apply textures to 3D objects:

In[4]:=4
✖
https://wolfram.com/xid/0giqxe-k1ucg
Out[4]=4
Wolfram Research (1991), Compile, Wolfram Language function, https://reference.wolfram.com/language/ref/Compile.html (updated 2010).
✖
Wolfram Research (1991), Compile, Wolfram Language function, https://reference.wolfram.com/language/ref/Compile.html (updated 2010).

Text

Wolfram Research (1991), Compile, Wolfram Language function, https://reference.wolfram.com/language/ref/Compile.html (updated 2010).

✖
Wolfram Research (1991), Compile, Wolfram Language function, https://reference.wolfram.com/language/ref/Compile.html (updated 2010).

CMS

Wolfram Language. 1991. "Compile." Wolfram Language & System Documentation Center. Wolfram Research. Last Modified 2010. https://reference.wolfram.com/language/ref/Compile.html.

✖
Wolfram Language. 1991. "Compile." Wolfram Language & System Documentation Center. Wolfram Research. Last Modified 2010. https://reference.wolfram.com/language/ref/Compile.html.

APA

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

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

BibTeX

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

✖
@misc{reference.wolfram_2025_compile, author="Wolfram Research", title="{Compile}", year="2010", howpublished="\url{https://reference.wolfram.com/language/ref/Compile.html}", note=[Accessed: 04-June-2025 ]}

BibLaTeX

@online{reference.wolfram_2025_compile, organization={Wolfram Research}, title={Compile}, year={2010}, url={https://reference.wolfram.com/language/ref/Compile.html}, note=[Accessed: 04-June-2025 ]}

✖
@online{reference.wolfram_2025_compile, organization={Wolfram Research}, title={Compile}, year={2010}, url={https://reference.wolfram.com/language/ref/Compile.html}, note=[Accessed: 04-June-2025 ]}