Perlin noise is a common algorithm used to generate procedural textures. This is a textbook implementation of the noise function:
This loads the
function:
This generates the permutation table used in the noise algorithm:
This sets the width and height. It also allocates the output memory:
This defines the parameters to the Perlin noise:
This calls the Perlin noise function. The output is a
CUDAMemory handle:
The memory is retrieved from the GPU and displayed as an image:
Putting the result in
Manipulate, you can see the output as parameters change:
With Perlin noise, you can create procedural landscapes. Define the width, height, and allocate memory for the landscape:
The parameters used define the landscape:
The data is retrieved and some image processing functions are used to smooth the elevation map:
The result is similar to a mountain range:
This deallocates the memory:
Varying parameters to the noise results in difference patterns. Here, wood texture is created:
The following are known parameters for wood:
This defines a helper function that recolors the grayscale image:
Here, the wood texture is generated:
As before, the result can be plotted onto a surface:
The original source code defines more noise functions. This loads all functions:
Here,
Manipulate is used to showcase the different noise functions:
This deallocates the memory:
The histogram algorithm places elements in a list in separate bins depending on their values. The following implements a histogram that places values between 0 and 255 in separate bins:
This loads the two CUDA kernel functions:
This gets sample data. An image is chosen in this case, and the
ImageData is flattened:
The algorithm requires some temporary data that would be used as intermediate histograms:
This computes sub-histograms and places them in the intermediate list generated before:
This merges the temporary histograms:
This gets the output histogram:
This unloads the temporary memory. Failing to do so results in a memory leak:
This plots the output histogram:
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 CUDA implementation is found in the following location:
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:
Minus the first term, the result agrees with
FoldList:
This deallocates the
CUDAMemory elements:
The reduction kernel is similar to
Fold in
Mathematica because it reduces a list given a binary operation. Whereas
scan kept the previous elements in the computation,
reduce discards them. This loads the reduction
CUDAFunction:
This sets the input and output buffers:
This performs the computation:
Each block reduces 512 elements of the list; therefore, you need multiple calls to reduce lists larger than 512 elements. This list is small, so no loop is necessary. This gets the output memory from the previous step, assigns the memory in
to
, and frees
:
This allocates a new output buffer:
This performs a second reduction:
The output is retrieved and the output buffer is unloaded:
The result agrees with Mathematica:
The following implements a color converter, converting from RGB color space to HSB. The CUDA implementation is in the file:
This loads the
function from the source file:
This sets the input image along with the input parameters:
This allocates memory for the output:
This converts the image to HSB space:
By default,
Image views the data in RGB space. This results in wrong output:
Use
ColorSpace
to get proper output:
The following code implements the Caesar cipher. The Caesar cipher is a simple cypher that adds the value 3 to each character in the text. Here is the CUDA implementation:
This loads some example text; the Declaration of Independence is loaded in this case:
Here, the function is loaded from the code string:
This calls the CUDA function and displays only the first 100 characters of the output:
The following implements a moving average:
This loads the
CUDAFunction defining the macro
as
:
This defines the input parameters and allocates memory for the output:
This calls the
CUDAFunction:
This gets the output memory:
Memory is unloaded:
The Black-Scholes formula is a commonly used formula used in financial computation.
CUDALink provides
CUDAFinancialDerivative, which can compute financial options. To demonstrate how it is written, implement as a simple version:
This loads the
CUDAFunction. Set the
to
, which means that
is interpreted as
:
This assigns the input parameters:
This calls the function:
This gets the output memory:
This unloads allocated memory:
.
, 
, and 
.
is passed, then 
is used by default. If 
is passed, then 
is used.
or 
.
can be called more than once with different arguments.
run in the same process as the Mathematica kernel.
are unloaded when the Mathematica kernel exits.
property of CUDAInformation.
must be set to True if the user wishes to use the unmangled name:
is defined based on hardware and 
:
uses the highest floating-point precision available on the device. In this case, it is double precision:
and 
are defined. To avoid detection, you can pass in the 
or 
options. This is equivalent to the above:
value to 
:
is detected based on the target precision. To force the use of a specific type, pass either 
or 
as type:
:
can be used to give information on compile failures. This source code has a syntax error:
Print gives the build log: 
was misspelled.
ignores the C portion of code. This allows you to write code that can be compiled by itself as a binary, but can also be loaded in as a CUDAFunction. The following loads a CUDA source file (mixed with C code) into Mathematica:
can specify the shared (local) memory size of the function at runtime. The following code uses shared memory to store global memory for gradient computation:
for shared memory. The block size is set to 256:
and the number of launch threads is set to the flattened length of the image:
must be set to False. This compiles a templated function into PTX byte code, using a dispatch function to determine what device function to call:
specifies that the input type is integer:
as an undefined macro:
to 
:
to 
:
defined as a float will return the wrong result if used when 
is set to 
.
is set to True.
. This code showcases how to define your own type in a kernel file, demonstrating this by considering sets of the form 
, where 
is a user-defined parameter. The kernel is defined here:
and 
variables:
is 
:
varies:
:
:
to CPointerType
:
128 times:
:
and height 
using CUDAMemoryAllocate:
(note that 
is the same as 
):
. Addition is simply vector addition. This specifies the Mandelbulb parameters (width, height, camera position, and light position):
EXAMPLES
Basic Examples 
Scope 
