# Documentation

### This is machine translation

Translated by
Mouseover text to see original. Click the button below to return to the English verison of the page.

Note: This page has been translated by MathWorks. Please click here
To view all translated materals including this page, select Japan from the country navigator on the bottom of this page.

# arrayfun

Apply function to each element of array

## Syntax

``B = arrayfun(func,A)``
``B = arrayfun(func,A1,...,An)``
``B = arrayfun(___,Name,Value)``
``[B1,...,Bm] = arrayfun(___)``

## Description

example

````B = arrayfun(func,A)` applies the function `func` to the elements of `A`, one element at a time. `arrayfun` then concatenates the outputs from `func` into the output array `B`, so that for the `i`th element of `A`, `B(i) = func(A(i))`. The input argument `func` is a function handle to a function that takes one input argument and returns a scalar. The output from `func` can have any data type, so long as objects of that type can be concatenated. The arrays `A` and `B` have the same size.You cannot specify the order in which `arrayfun` calculates the elements of `B` or rely on them being done in any particular order.```
````B = arrayfun(func,A1,...,An)` applies `func` to the elements of the arrays `A1,...,An`, so that ```B(i) = func(A1(i),...,An(i))```. The function `func` must take `n` input arguments and return a scalar. The arrays `A1,...,An` all must have the same size.```

example

````B = arrayfun(___,Name,Value)` applies `func` with additional options specified by one or more `Name,Value` pair arguments. For example, to return output values in a cell array, specify `'UniformOutput',false`. You can return `B` as a cell array when `func` returns values that cannot be concatenated into an array. You can use `Name,Value` pair arguments with the input arguments of either of the previous syntaxes.```

example

````[B1,...,Bm] = arrayfun(___)` returns multiple output arrays `B1,...,Bm` when `func` returns `m` output values. `func` can return output arguments that have different data types, but the data type of each output must be the same each time `func` is called. You can use this syntax with any of the input arguments of the previous syntaxes.The number of output arguments from `func` need not be the same as the number of input arguments specified by `A1,...,An`.```

## Examples

collapse all

Create a nonscalar structure array. Each structure has a field that contains a vector of random numbers. The vectors have different sizes.

```S(1).f1 = rand(1,5); S(2).f1 = rand(1,10); S(3).f1 = rand(1,15)```
```S = 1x3 struct array with fields: f1 ```

Calculate the mean for each field in `S` by using the `arrayfun` function. You cannot use `structfun` for this calculation because the input argument to `structfun` must be a scalar structure.

`A = arrayfun(@(x) mean(x.f1),S)`
```A = 0.6786 0.6216 0.6069 ```

Create a structure array in which each structure has two fields containing numeric arrays.

```S(1).X = 5:5:100; S(1).Y = rand(1,20); S(2).X = 10:10:100; S(2).Y = rand(1,10); S(3).X = 20:20:100; S(3).Y = rand(1,5)```
```S = 1x3 struct array with fields: X Y ```

Plot the numeric arrays. Return an array of chart line objects from the `plot` function and use them to add different markers to each set of data points. `arrayfun` can return arrays of any data type so long as objects of that data type can be concatenated.

```figure hold on p = arrayfun(@(a) plot(a.X,a.Y),S); p(1).Marker = 'o'; p(2).Marker = '+'; p(3).Marker = 's'; hold off```

Create a nonscalar structure array. Each structure has a field that contains numeric matrices.

```S(1).f1 = rand(3,5); S(2).f1 = rand(6,10); S(3).f1 = rand(4,2)```
```S = 1x3 struct array with fields: f1 ```

Calculate the mean for each field in `S` by using the `arrayfun` function. `mean` returns vectors containing the mean of each column, so the means cannot be returned as an array. To return the means in a cell array, specify the `'UniformOutput',false` name-value pair.

`A = arrayfun(@(x) mean(x.f1),S,'UniformOutput',false)`
```A = 1x3 cell array {1x5 double} {1x10 double} {1x2 double} ```

Create a nonscalar structure array.

```S(1).f1 = 1:10; S(2).f1 = [2; 4; 6]; S(3).f1 = []```
```S = 1x3 struct array with fields: f1 ```

Calculate the sizes of each field of `S` by using the `arrayfun` function. The number of rows and columns are each in 1-by-3 numeric arrays.

`[nrows,ncols] = arrayfun(@(x) size(x.f1),S)`
```nrows = 1 3 0 ```
```ncols = 10 1 0 ```

## Input Arguments

collapse all

Function to apply to the elements of the input arrays, specified as a function handle.

`func` can correspond to more than one function file and therefore can represent a set of overloaded functions. In these cases, MATLAB® determines which function to call based on the class of the input arguments.

Example: `B = arrayfun(@round,A)` returns the integer part of each element of `A`.

Input array. `A` can have any data type.

If you define the class that `A` belongs to, and you also overload the `subsref` or `size` methods of `A`, then `arrayfun` places these requirements on `A`:

• The `size` method of `A` must return an array of doubles.

• `A` must support linear indexing.

• The product of the sizes returned by the `size` method must not exceed the limit of `A`, as defined by linear indexing into `A`.

### Name-Value Pair Arguments

Specify optional comma-separated pairs of `Name,Value` arguments. `Name` is the argument name and `Value` is the corresponding value. `Name` must appear inside single quotes (`' '`). You can specify several name and value pair arguments in any order as `Name1,Value1,...,NameN,ValueN`.

Example: `A = arrayfun(@(x) mean(x.f1),S,'UniformOutput',false)` returns the means in a cell array. `S` is a structure array in which each structure has a field named `f1`.

collapse all

True or false, specified as the comma-separated pair consisting of `'UniformOuput'` and either `1` (`true`) or `0` (`false`).

Value of `'UniformOutput'`

Description

`1` (`true`)

`func` must return scalars that `arrayfun` concatenates into arrays.

`0` (`false`)

`arrayfun` returns the outputs of `func` in cell arrays. The outputs of `func` can have any sizes and different data types.

Function to catch errors, specified as the comma-separated pair consisting of `'ErrorHandler'` and a function handle. If `func` throws an error, then the error handler specified by `'ErrorHandler'` catches the error and takes the action specified in the function. The error handler either must throw an error or return the same number of outputs as `func`. If the value of `'UniformOutput'` is true, then the output arguments of the error handler must be scalars and have the same data type as the outputs of `func`.

The first input argument of the error handler is a structure with these fields:

• `identifier` — Error identifier

• `message` — Error message text

• `index` — Linear index into the input arrays at which `func` threw the error

The remaining input arguments to the error handler are the input arguments for the call to `func` that made `func` throw the error.

Suppose `func` returns two doubles as output arguments. You can specify the error handler as `'ErrorHandler',@errorFunc`, where `errorFunc` is a function that raises a warning and returns two output arguments.

```function [A,B] = errorFunc(S,varargin) warning(S.identifier, S.message); A = NaN; B = NaN; end```

If you do not specify `'ErrorHandler'`, then `arrayfun` rethrows the error thrown by `func`.

## Output Arguments

collapse all

Output array, returned as an array of any data type or as a cell array.

By default, `arrayfun` concatenates the outputs from `func` into an array. `func` must return scalars. If `func` returns objects, then the class that the objects belong to must meet these requirements.

• Support assignment by linear indexing into the object array

• Have a `reshape` method that returns an array that has the same size as the input

If the value of the `'UniformOutput'` name-value pair argument is `0` (`false`), then `arrayfun` returns outputs in a cell array. In that case, the outputs from `func` can have any sizes and different data types.

## See Also

### Topics

#### Introduced before R2006a

Was this topic helpful?

#### Beyond Excel: The Manager's Guide to Solving the Big Data Conundrum

Download white paper