Main Content

# colon, :

Vector creation, array subscripting, and `for`-loop iteration

## Syntax

```x = j:k
x = j:i:k
A(:,n)
A(m,:)
A(:)
A(j:k)
```

## Description

The colon is one of the most useful operators in MATLAB®. It can create vectors, subscript arrays, and specify `for` iterations.

example

````x = j:k` creates a unit-spaced vector `x` with elements `[j,j+1,j+2,...,j+m]` where ```m = fix(k-j)```. If `j` and `k` are both integers, then this is simply `[j,j+1,...,k]`.```

example

````x = j:i:k` creates a regularly-spaced vector `x` using `i` as the increment between elements. The vector elements are roughly equal to `[j,j+i,j+2*i,...,j+m*i]` where `m = fix((k-j)/i)`. However, if `i` is not an integer, then floating point arithmetic plays a role in determining whether `colon` includes the endpoint `k` in the vector, since `k` might not be exactly equal to `j+m*i`. If you specify nonscalar arrays, then MATLAB interprets `j:i:k` as `j(1):i(1):k(1)`.```
````x = colon(j,k)` and `x = colon(j,i,k)` are alternate ways to execute the commands `j:k` and `j:i:k`, but are rarely used. These syntaxes enable operator overloading for classes.```

example

````A(:,n)`, `A(m,:)`, `A(:)`, and `A(j:k)` are common indexing expressions for a matrix `A` that contain a colon. When you use a colon as a subscript in an indexing expression, such as `A(:,n)`, it acts as shorthand to include all subscripts in a particular array dimension. It is also common to create a vector with a colon for the purposes of indexing, such as `A(j:k)`. Some indexing expressions combine both uses of the colon, as in `A(:,j:k)`.Common indexing expressions that contain a colon are:`A(:,n)` is the `n`th column of matrix `A`.`A(m,:)` is the `m`th row of matrix `A`.`A(:,:,p)` is the `p`th page of three-dimensional array `A`.`A(:)` reshapes all elements of `A` into a single column vector. This has no effect if `A` is already a column vector.`A(:,:)` reshapes all elements of `A` into a two-dimensional matrix. This has no effect if `A` is already a matrix or vector.`A(j:k)` uses the vector `j:k` to index into `A` and is therefore equivalent to the vector `[A(j), A(j+1), ..., A(k)]`.`A(:,j:k)` includes all subscripts in the first dimension but uses the vector `j:k` to index in the second dimension. This returns a matrix with columns ```[A(:,j), A(:,j+1), ..., A(:,k)]```.```

## Examples

collapse all

Create a unit-spaced vector of numbers between 1 and 10. The colon operator uses a default increment of +1.

`x = 1:10`
```x = 1×10 1 2 3 4 5 6 7 8 9 10 ```

Create vectors that increment or decrement by a specified value.

Create a vector whose elements increment by 0.1.

`x = 0:0.1:1`
```x = 1×11 0 0.1000 0.2000 0.3000 0.4000 0.5000 0.6000 0.7000 0.8000 0.9000 1.0000 ```

Create a vector whose elements decrement by -2.

`y = 10:-2:0`
```y = 1×6 10 8 6 4 2 0 ```

Examine several ways to index a matrix using a colon `:`.

Create a 3-by-3 matrix. Index the first row.

`A = magic(3)`
```A = 3×3 8 1 6 3 5 7 4 9 2 ```
`A(1,:)`
```ans = 1×3 8 1 6 ```

Index the second and third column.

`A(:,2:3)`
```ans = 3×2 1 6 5 7 9 2 ```

Reshape the matrix into a column vector.

`A(:)`
```ans = 9×1 8 3 4 1 5 9 6 7 2 ```

In the context of a `for`-loop, the colon specifies the loop iterations.

Write a `for`-loop that squares a number for values of `n` between 1 and 4.

```for n = 1:4 n^2 end```
```ans = 1 ```
```ans = 4 ```
```ans = 9 ```
```ans = 16 ```

## Input Arguments

collapse all

Starting vector value, specified as a real numeric scalar. If ```j < k``` so that the output vector is not empty, then `j` is the first element in the vector.

Example: `x = 0:5`

Example: ```x = 0:0.5:5```

Data Types: `single` | `double` | `int8` | `int16` | `int32` | `int64` | `uint8` | `uint16` | `uint32` | `uint64` | `char` | `datetime` | `duration`

Ending vector value, specified as a real numeric scalar. `k` is the last value in the vector only when the increment lines up to exactly land on `k`. For example, the vector `0:5` includes 5 as the last value, but `0:0.3:1` does not include the value 1 as the last value since the increment does not line up with the endpoint.

Example: `x = 0:5`

Example: ```x = 0:0.5:5```

Data Types: `single` | `double` | `int8` | `int16` | `int32` | `int64` | `uint8` | `uint16` | `uint32` | `uint64` | `char` | `datetime` | `duration`

Increment between vector elements, specified as a real numeric scalar.

Example: `x = 0:0.5:5`

Data Types: `single` | `double` | `int8` | `int16` | `int32` | `int64` | `uint8` | `uint16` | `uint32` | `uint64` | `char` | `datetime` | `duration`

## Output Arguments

collapse all

Regularly-spaced vector, returned as a row vector. If ```j > k```, then `x = j:k` is an empty matrix. More generally, the syntax `x = j:i:k` returns an empty matrix when:

• `i`, `j`, or `k` is an empty input

• `i == 0`

• `i > 0` and `j > k`

• `i < 0` and `j < k`

## Tips

• The `for` reference page has a description of how to use `:` in the context of loop statements.

• `linspace` is similar to the colon operator `:`, but it gives direct control over the number of points and always includes the endpoints. The sibling function `logspace` generates logarithmically spaced values.

• When you create a vector to index into a cell array or structure array (such as `cellName{:}` or `structName(:).fieldName`), MATLAB returns multiple outputs in a comma-separated list. For more information, see How to Use the Comma-Separated Lists.

## See Also

### Topics

Introduced before R2006a

Download ebook