Next: , Previous: , Up: Cell Arrays   [Contents][Index]

#### 6.2.3 Indexing Cell Arrays

As shown in see Basic Usage of Cell Arrays elements can be extracted from cell arrays using the ‘{’ and ‘}’ operators. If you want to extract or access subarrays which are still cell arrays, you need to use the ‘(’ and ‘)’ operators. The following example illustrates the difference:

```c = {"1", "2", "3"; "x", "y", "z"; "4", "5", "6"};
c{2,3}
⇒ ans = z

c(2,3)
⇒ ans =
{
[1,1] = z
}
```

So with ‘{}’ you access elements of a cell array, while with ‘()’ you access a sub array of a cell array.

Using the ‘(’ and ‘)’ operators, indexing works for cell arrays like for multi-dimensional arrays. As an example, all the rows of the first and third column of a cell array can be set to `0` with the following command:

```c(:, [1, 3]) = {0}
⇒  =
{
[1,1] = 0
[2,1] = 0
[3,1] = 0
[1,2] = 2
[2,2] =  10
[3,2] =  20
[1,3] = 0
[2,3] = 0
[3,3] = 0
}
```

Note, that the above can also be achieved like this:

```c(:, [1, 3]) = 0;
```

Here, the scalar ‘0’ is automatically promoted to cell array ‘{0}’ and then assigned to the subarray of `c`.

To give another example for indexing cell arrays with ‘()’, you can exchange the first and the second row of a cell array as in the following command:

```c = {1, 2, 3; 4, 5, 6};
c([1, 2], :) = c([2, 1], :)
⇒ =
{
[1,1] =  4
[2,1] =  1
[1,2] =  5
[2,2] =  2
[1,3] =  6
[2,3] =  3
}
```

Accessing multiple elements of a cell array with the ‘{’ and ‘}’ operators will result in a comma-separated list of all the requested elements (see Comma Separated Lists). Using the ‘{’ and ‘}’ operators the first two rows in the above example can be swapped back like this:

```[c{[1,2], :}] = deal (c{[2, 1], :})
⇒ =
{
[1,1] =  1
[2,1] =  4
[1,2] =  2
[2,2] =  5
[1,3] =  3
[2,3] =  6
}
```

As for struct arrays and numerical arrays, the empty matrix ‘[]’ can be used to delete elements from a cell array:

```x = {"1", "2"; "3", "4"};
x(1, :) = []
⇒ x =
{
[1,1] = 3
[1,2] = 4
}
```

The following example shows how to just remove the contents of cell array elements but not delete the space for them:

```x = {"1", "2"; "3", "4"};
x(1, :) = {[]}
⇒ x =
{
[1,1] = [](0x0)
[2,1] = 3
[1,2] = [](0x0)
[2,2] = 4
}
```

The indexing operations operate on the cell array and not on the objects within the cell array. By contrast, `cellindexmat` applies matrix indexing to the objects within each cell array entry and returns the requested values.

Built-in Function: y = cellindexmat (x, varargin)

Perform indexing of matrices in a cell array.

Given a cell array of matrices x, this function computes

```Y = cell (size (X));
for i = 1:numel (X)
Y{i} = X{i}(varargin{:});
endfor
```