Templated functions can be simulated using macros. Leave as an undefined macro:

Set the macro to during compilation:

Sets to instead:

OpenCLFunctionLoad can be used to specify "Local" or "Shared" memory on launch. The following code uses shared memory to store global memory for gradient computation:

This specifies the input arguments, with the last argument being "Shared" for shared memory. The block size is set to 256:

This computes the flattened length of a grayscale image:

This invokes the function. The shared memory size is set to (blockSize+2)⋆sizeof (int) and the number of launch threads is set to the flattened length of the image:

A nicer way of specifying the shared memory size is using types:

Using shared memory types, you need not pass in the size of the type:

The input can be images; here you write code that performs linear interpolation between images (this can be done using ImageCompose):

This loads OpenCLFunction from the source code above:

This sets the height, width, and channel values. It also allocates memory for the output:

This calls the function with {width,height} threads:

This gets the memory and displays it as an image:

You can take the above and make a function OpenCLImageLinearCombine:

The function now has similar syntax to ImageCompose:

A Manipulate can be used to play with the interpolation coefficients:

Effects can be made; in this example, a smooth animation is viewed:

Uniform random number generators are common seed problems in many applications. This implements uniform random number generators in OpenCL:

This loads the source as an OpenCLFunction. This algorithm uses an image to provide an upper bound to the random number:

This calls OpenCLFunction; note that you can pass images directly into an OpenCLFunction so long as it can be interpreted using the appropriate specified type:

Notice that this is not a regular duck image; it is a 4-channel image with alpha channel set to 1 (using SetAlphaChannel):

The random output can be used to detect important edges in an image:

The Mersenne Twister is another uniform random number generator algorithm (more sophisticated than the one mentioned above). The implementation is located here:

This loads OpenCLFunction; you specify the type _Real, which means that the Real type is dependent on the CPU capabilities (whether it supports double precision or not):

This sets up the Mersenne Twister's input and output parameters (for more information, refer to the algorithm description):

This invokes OpenCLFunction:

This plots the output's results:

If the output is timed:

There is almost an 11× increase in speed:

The scan, or prefix sum, algorithm is similar to FoldList and is a very useful primitive algorithm that can be used in a variety of scenarios. The OpenCL implementation is found in:

This loads the three kernels used in computation:

This generates random input data:

This allocates the output buffer:

This computes the block and grid dimensions:

A temporary buffer is needed in computation:

This performs the scan operation:

This retrieves the output buffer:

This deallocates the OpenCLMemory elements:

Matrix transpose is a fundamental algorithm in many applications. This specifies the inputs:

This loads OpenCLFunction:

This calls OpenCLFunction:

This shows the MatrixForm of the result:

The result agrees with the Wolfram Language:

Matrix multiplication is implemented here:

This defines the block size:

This loads OpenCLFunction; note it is specified that the input must be rank 2:

This creates random input and allocates the output:

This calls OpenCLFunction:

This gets the output memory using OpenCLMemoryGet:

The output agrees with the Wolfram Language:

The one-dimensional discrete fast Fourier transform can be implemented using OpenCLLink; this implementation assumes that the input is a power of 2:

This loads OpenCLFunction using OpenCLFunctionLoad:

This creates input and output lists:

This calls the output memory and creates a complex list, displaying only the first 50 elements:

The result agrees with Fourier:

Black–Scholes models financial derivative investments and is implemented in OpenCL:

This loads OpenCLFunction:

This assigns the input parameters:

This invokes OpenCLFunction:

This gets the call values:

The result agrees with the output of FinancialDerivative:

For timing, the number of options to be valuated is increased:

On the C2050, it takes 1/100 of a second to valuate 2048 options:

On a Core i7 950, FinancialDerivative takes 1.13 seconds. This is a speedup of 280×. Note that increasing the number of options will exhibit more speedups:

Recursive Gaussian is used to approximate the Gaussian filter. The Gaussian matrix is separable:

It can be written as the outer product of two 1D Gaussians:

Locate the implementation of the recursive Gaussian:

Load two functions using OpenCLFunctionLoad:

Specifies the value in the Gaussian :

Calculate the normal distribution:

The Wolfram Language can plot the distribution:

Calculate the recursive Gaussian parameters:

Allocate OpenCLMemory for the input, output, and temporary storage:

Perform the Gaussian horizontally, then transpose, then perform the Gaussian vertically, and finally transpose to get the full Gaussian:

Reconstruct the image from the data:

Again you compare timing:

And notice a 4× performance boost:

Bitonic sort sorts a given set of integers. It is similar in principle to merge sort. The OpenCL implementation only works on lists of length of a power of 2 and can be found here:

This sets the length of the input and loads it. The direction denotes whether to sort from highest to lowest or lowest to highest. In this case, you sort from lowest to highest:

This gets the input list:

This calls bitonic sort, similar to merge sort; multiple calls are needed for a full sort:

The output list is retrieved sorted:

The Mandelbrot set plots all points satisfying the recurrence equation with a complex number. The following implements the set in OpenCL (a slightly more complicated coloring strategy is used to ensure colors have smooth transition):

The Mandelbrot set is a restricted form of the Julia set; here is the code for the Julia set:

This defines the input memory and parameters:

This loads OpenCLFunction:

This computes the Julia set and plots it using ReliefPlot:

This computes the Julia set and displays it as a grayscale image:

ImageAdjust rescales the image to input high and low values. Gamma correction is also considered. The following defines a simplified version of ImageAdjust in OpenCL:

This loads OpenCLFunction:

This defines a simple Wolfram Language wrapper function to make the OpenCL function have similar syntax to ImageAdjust:

This adjusts the image by rescaling the values between 0.3 and 0.8 to 0.0 and 1.0:

This adjusts the image by rescaling the values using Manipulate:

This adjusts the image by rescaling the values between 0.3 and 0.8 to 0.0 and 1.0:

In this example, you compute the position of each particle in a box with varying initial forces. You delegate the particle physics simulation to OpenCL, while all the rest is done in the Wolfram Language:

This defines the OpenCL code and loads the function into the Wolfram Language:

The N-body simulation is a classic Newtonian problem. This implements it in OpenCL:

This loads OpenCLFunction:

The number of particles, time step, and epsilon distance are chosen:

This sets the input and output memories:

This calls the NBody function:

This plots the body points:

This shows the result as a Dynamic:

OpenCLLink can use SymbolicC's code generation capabilities. To use SymbolicC, the user needs to load it:

OpenCLLink can use SymbolicC's code generation capabilities; here a method toSymbolicC is defined that takes a Wolfram Language statement and translates it to a SymbolicC expression (it cannot translate all Wolfram Language commands, but they can be added by the user):

Wolfram Language expressions can be transformed:

To translate to C, the user uses ToCCodeString:

You can tie this with OpenCLLink's symbolic code generation capabilities to create an OpenCLMapSource function:

OpenCLMapSource can work with pure Wolfram Language functions:

You can also use the code to work with predefined Wolfram Language functions:

The above code can then be loaded using OpenCLFunctionLoad:

The function can be evaluated:

To make this general, you can implement an OpenCLMap function:

The function can be evaluated. Here, the addTwo function is implemented:

Here, the BitNot operator is used: