#### 6.3.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] = y
              [3,2] = 5
              [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.

`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{1}, varargin{2}, ..., varargin{N});
      endfor

  The indexing arguments may be scalar (`2`), arrays (`[1, 3]`), ranges (`1:3`), or the colon operator (`":"`). However, the indexing keyword `end` is not available.

  See also: cellslices, cellfun.