Note: This page has been translated by MathWorks. Click here to see

To view all translated materials including this page, select Country from the country navigator on the bottom of this page.

To view all translated materials including this page, select Country from the country navigator on the bottom of this page.

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 MEX-function).

For more detailed information, see Run Element-wise 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.

The first time you call

`arrayfun`

to run a particular function on the GPU, there is some overhead time to set up the function for GPU execution. Subsequent calls of`arrayfun`

with the same function can run significantly faster.Nonsingleton dimensions of input arrays must match each other. In other words, the corresponding dimensions of arguments

`B`

,`C`

, etc., must be equal to each other, or equal to one. Whenever a dimension of an input array is singleton (equal to 1),`arrayfun`

uses singleton expansion to virtually replicate the array along that dimension to match the largest of the other arrays in that dimension. In the case where a dimension of an input array is singleton and the corresponding dimension in another argument array is zero,`arrayfun`

virtually diminishes the singleton dimension to 0.The size of the output array

`A`

is such that each dimension is the largest of the input arrays in that dimension for nonzero size, or zero otherwise. Notice in the following code how dimensions of size 1 are scaled up or down to match the size of the corresponding dimension in the other argument:R1 = rand(2,5,4,'gpuArray'); R2 = rand(2,1,4,3,'gpuArray'); R3 = rand(1,5,4,3,'gpuArray'); R = arrayfun(@(x,y,z)(x+y.*z),R1,R2,R3); size(R)

2 5 4 3

R1 = rand(2,2,0,4,'gpuArray'); R2 = rand(2,1,1,4,'gpuArray'); R = arrayfun(@plus,R1,R2); size(R)

2 2 0 4

Because the operations supported by

`arrayfun`

are strictly element-wise, and each element’s computation is performed independently of the others, certain restrictions are imposed:Input and output arrays cannot change shape or size.

Functions like

`rand`

do not support size specifications. Arrays of random numbers have independent streams for each element.

For more limitations and details, see Tips and Restrictions.

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);