Apply function to each element of array on GPU
A = arrayfun(FUN, B)
A = arrayfun(FUN,B,C,...)
[A,B,...] = arrayfun(FUN,C,...)
This method of a gpuArray object is very similar in behavior
to the MATLAB^{®} function arrayfun
,
except that the actual evaluation of the function happens on the GPU,
not on the CPU. Thus, any required data not already on the GPU is
moved to GPU memory, the MATLAB function passed in for evaluation
is compiled for the GPU, and then executed on the GPU. All the output
arguments return as gpuArray objects, whose data you can retrieve
with the gather
method.
A = arrayfun(FUN, B)
applies the function
specified by FUN
to each element of the gpuArray B
,
and returns the results in gpuArray A
. A
is
the same size as B
, and A(i,j,...)
is
equal to FUN(B(i,j,...))
. FUN
is
a function handle to a function that takes one input argument and
returns a scalar value. FUN
must return values
of the same class each time it is called. The input data must be
an array of one of the following types: numeric, logical, or gpuArray.
The order in which arrayfun
computes elements
of A
is not specified and should not be relied
on.
FUN
must be a handle to a function that is
written in the MATLAB language (i.e., not a MEXfunction).
For more detailed information, see Run Elementwise MATLAB Code on GPU. For the subset of the
MATLAB language that is currently supported by arrayfun
on
the GPU, see Supported MATLAB Code.
A = arrayfun(FUN,B,C,...)
evaluates FUN
using
elements of arrays B
, C
, ...
as input arguments with singleton expansion enabled. The resulting
gpuArray element A(i,j,...)
is equal to FUN(B(i,j,...),C(i,j,...),...)
.
The inputs B
, C
, ... must all
have the same size or be scalar. Any scalar inputs are scalar expanded
before being input to the function FUN
.
One or more of the inputs B
, C
,
... must be a gpuArray; any of the others can reside in CPU memory.
Each array that is held in CPU memory is converted to a gpuArray before
calling the function on the GPU. If you plan to use an array in several
different arrayfun
calls, it is more efficient
to convert that array to a gpuArray before making the series of calls
to arrayfun
.
[A,B,...] = arrayfun(FUN,C,...)
, where FUN
is
a function handle to a function that returns multiple outputs, returns
gpuArrays A
, B
, ..., each corresponding
to one of the output arguments of FUN
. arrayfun
calls FUN
each
time with as many outputs as there are in the call to arrayfun
.
FUN
can return output arguments having different
classes, but the class of each output must be the same each time FUN
is
called. This means that all elements of A
must
be the same class; B
can be a different class from A
,
but all elements of B
must be of the same class,
etc.
Although the MATLAB arrayfun
function
allows you to specify optional parameter name/value pairs, the gpuArray arrayfun
method
does not support these options.
Tips

If you define a MATLAB function as follows:
function [o1,o2] = aGpuFunction(a,b,c)
o1 = a + b;
o2 = o1 .* c + 2;
You can evaluate this on the GPU.
s1 = gpuArray(rand(400)); s2 = gpuArray(rand(400)); s3 = gpuArray(rand(400)); [o1,o2] = arrayfun(@aGpuFunction,s1,s2,s3); whos
Name Size Bytes Class o1 400x400 108 gpuArray o2 400x400 108 gpuArray s1 400x400 108 gpuArray s2 400x400 108 gpuArray s3 400x400 108 gpuArray
Use gather
to retrieve the data from the
GPU to the MATLAB workspace.
d = gather(o2);