# Array Indexing

In MATLAB®, there are three primary approaches to accessing array elements based on their location (index) in the array. These approaches are indexing by position, linear indexing, and logical indexing. You can also use mixed indexing by combining both positional and logical indexing.

### Indexing with Element Positions

The most common approach is to explicitly specify the indices of the elements. For example, to access a single element of a matrix, specify the row number followed by the column number of the element.

`A = [1 2 3 4; 5 6 7 8; 9 10 11 12; 13 14 15 16]`
```A = 4×4 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 ```
`e = A(3,2)`
```e = 10 ```

`e` is the element in the 3,2 position (third row, second column) of `A`.

You can also reference multiple elements at a time by specifying their indices in a vector. For example, access the first and third elements of the second row of `A`.

`r = A(2,[1 3])`
```r = 1×2 5 7 ```

To access elements in a range of rows or columns, use the `colon` operator. For example, access the elements in the first through third rows and the second through fourth columns of `A`.

`r = A(1:3,2:4)`
```r = 3×3 2 3 4 6 7 8 10 11 12 ```

An alternative way to access those elements is to use the keyword `end` to represent the last column. This approach lets you specify the last column without knowing exactly how many columns are in `A`.

`r = A(1:3,2:end)`
```r = 3×3 2 3 4 6 7 8 10 11 12 ```

If you want to access all of the rows or columns, use the colon operator by itself. For example, return the entire third column of `A`.

`r = A(:,3)`
```r = 4×1 3 7 11 15 ```

In general, you can use indexing to access elements of any array in MATLAB regardless of its data type or dimensions. For example, directly access a column of a `datetime` array.

`t = [datetime(2018,1:5,1); datetime(2019,1:5,1)]`
```t = 2x5 datetime 01-Jan-2018 01-Feb-2018 01-Mar-2018 01-Apr-2018 01-May-2018 01-Jan-2019 01-Feb-2019 01-Mar-2019 01-Apr-2019 01-May-2019 ```
`march1 = t(:,3)`
```march1 = 2x1 datetime 01-Mar-2018 01-Mar-2019 ```

For higher-dimensional arrays, expand the syntax to match the array dimensions. Consider a random 3-by-3-by-3 numeric array. Access the element in the second row, third column, and first sheet of the array.

```A = rand(3,3,3); e = A(2,3,1)```
```e = 0.5469 ```

For more information on working with multidimensional arrays, see Multidimensional Arrays.

### Indexing with Single Index

Another approach for accessing elements of an array is to use only a single index, regardless of the size or dimensions of the array. This approach is known as linear indexing. While MATLAB displays arrays according to their defined sizes and shapes, they are actually stored in memory as a single column of elements. A good way to visualize this concept is with a matrix. While the following array is displayed as a 3-by-3 matrix, MATLAB stores it as a single column made up of the columns of `A` appended one after the other. The stored vector contains the sequence of elements `12`, `45`, `33`, `36`, `29`, `25`, `91`, `48`, `11`, and can be displayed using a single colon.

`A = [12 36 91; 45 29 48; 33 25 11]`
```A = 3×3 12 36 91 45 29 48 33 25 11 ```
`Alinear = A(:)`
```Alinear = 9×1 12 45 33 36 29 25 91 48 11 ```

For example, the 3,2 element of `A` is `25`, and you can access it using the syntax `A(3,2)`. You can also access this element using the syntax `A(6)`, since `25` is the sixth element of the stored vector sequence.

`e = A(3,2)`
```e = 25 ```
`elinear = A(6)`
```elinear = 25 ```

While linear indexing can be less intuitive visually, it can be powerful for performing certain computations that are not dependent on the size or shape of the array. For example, you can easily sum all of the elements of `A` without having to provide a second argument to the `sum` function.

`s = sum(A(:))`
```s = 330 ```

The `sub2ind` and `ind2sub` functions help to convert between original array indices and their linear version. For example, compute the linear index of the 3,2 element of `A`.

`linearidx = sub2ind(size(A),3,2)`
```linearidx = 6 ```

Convert the linear index back to its row and column form.

`[row,col] = ind2sub(size(A),6)`
```row = 3 ```
```col = 2 ```

### Indexing with Logical Values

Using true and false logical indicators is another useful approach to index into arrays, particularly when working with conditional statements. For example, suppose you want to know if the elements of a matrix `A` are less than the corresponding elements of another matrix `B`. The less-than operator returns a logical array whose elements are `1` where an element in `A` is smaller than the corresponding element in `B`.

`A = [1 2 6; 4 3 6]`
```A = 2×3 1 2 6 4 3 6 ```
`B = [0 3 7; 3 7 5]`
```B = 2×3 0 3 7 3 7 5 ```
`ind = A < B`
```ind = 2x3 logical array 0 1 1 0 1 0 ```

Now that you know the locations of the elements meeting the condition, you can inspect the individual values using `ind` as the index array. MATLAB matches the locations of the value 1 in `ind` to the corresponding elements of `A` and `B`, and lists their values in a column vector.

`Avals = A(ind)`
```Avals = 3×1 2 3 6 ```
`Bvals = B(ind)`
```Bvals = 3×1 3 7 7 ```

MATLAB "`is`" functions also return logical arrays that indicate which elements of the input meet a certain condition. For example, check which elements of a string vector are missing using the `ismissing` function.

```str = ["A" "B" missing "D" "E" missing]; ind = ismissing(str)```
```ind = 1x6 logical array 0 0 1 0 0 1 ```

Suppose you want to find the values of the elements that are not missing. Use the `~` operator with the index vector `ind` to do this.

`strvals = str(~ind)`
```strvals = 1x4 string "A" "B" "D" "E" ```

For more examples using logical indexing, see Find Array Elements That Meet Conditions.

### Mixed Indexing with Logical Values and Element Positions

You can also use a combination of positional and logical indexing to access array elements.

For example, create a 5-by-5 matrix.

`A = magic(5)`
```A = 5×5 17 24 1 8 15 23 5 7 14 16 4 6 13 20 22 10 12 19 21 3 11 18 25 2 9 ```

Suppose you want to select the elements of A that are located in rows with prime indices and in columns with indices 2, 3, and 4.

To do this, create a vector `B` that represents the indices of the rows in `A`.

`B = (1:size(A,1))`
```B = 1×5 1 2 3 4 5 ```

Use the `isprime` function to determine which elements in `B` are prime. The result is a logical array that you can use to index into the rows of `A`.

`rows = isprime(B)`
```rows = 1x5 logical array 0 1 1 0 1 ```

Next, define the columns you want to select, which are located in positions 2 to 4.

`cols = 2:4`
```cols = 1×3 2 3 4 ```

Use logical indexing to select the rows of `A` located at prime number positions, as defined by `rows`. Then, use indexing by position to select the columns of `A` ranging from positions 2 to 4, as defined by `cols`.

`A(rows,cols)`
```ans = 3×3 5 7 14 6 13 20 18 25 2 ```