Documentation

### This is machine translation

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

# cummin

Cumulative minimum

## Syntax

``M = cummin(A)``
``M = cummin(A,dim)``
``M = cummin(___,direction)``
``M = cummin(___,nanflag)``

## Description

example

````M = cummin(A)` returns the cumulative minimum elements of `A`. By default, `cummin(A)` operates along the first array dimension whose size does not equal 1.If `A` is a vector, then `cummin(A)` returns a vector of the same size containing the cumulative minima of `A`.If `A` is a matrix, then `cummin(A)` returns a matrix of the same size containing the cumulative minima in each column of `A`.If `A` is a multidimensional array, then `cummin(A)` returns an array of the same size containing the cumulative minima along the first array dimension of `A` whose size does not equal 1.```

example

````M = cummin(A,dim)` returns the cumulative minima along the dimension `dim`. For example, if `A` is a matrix, then `cummin(A,2)` returns the cumulative minima along the rows of `A`.```

example

````M = cummin(___,direction)` optionally specifies the direction using any of the previous syntaxes. You must specify `A` and, optionally, can specify `dim`. For instance, `cummin(A,2,'reverse')` returns the cumulative minima of `A` by working from end to beginning of the second dimension of `A`.```

example

````M = cummin(___,nanflag)` specifies whether to include or omit `NaN` values from the calculation for any of the previous syntaxes. `cummin(A,'includenan')` includes all `NaN` values in the calculation while `cummin(A,'omitnan')` ignores them.```

## Examples

collapse all

Find the cumulative minima of a 1-by-10 vector of random integers.

`v = randi([0,10],1,10)`
```v = 1×10 8 9 1 10 6 1 3 6 10 10 ```
`M = cummin(v)`
```M = 1×10 8 8 1 1 1 1 1 1 1 1 ```

Find the cumulative minima of the columns of a 3-by-3 matrix.

`A = [3 5 2; 1 6 3; 7 8 1]`
```A = 3×3 3 5 2 1 6 3 7 8 1 ```
`M = cummin(A)`
```M = 3×3 3 5 2 1 5 2 1 5 1 ```

Find the cumulative minima of the rows of a 3-by-3 matrix.

`A = [3 5 2; 1 6 3; 7 8 1]`
```A = 3×3 3 5 2 1 6 3 7 8 1 ```
`M = cummin(A,2)`
```M = 3×3 3 3 2 1 1 1 7 7 1 ```

Calculate the cumulative minima in the third dimension of a 2-by-2-by-3 array. Specify `direction` as `'reverse'` to work from the end of the third dimension to the beginning.

`A = cat(3,[1 2; 3 4],[9 10; 11 12],[5 6; 7 8])`
```A = A(:,:,1) = 1 2 3 4 A(:,:,2) = 9 10 11 12 A(:,:,3) = 5 6 7 8 ```
`M = cummin(A,3,'reverse')`
```M = M(:,:,1) = 1 2 3 4 M(:,:,2) = 5 6 7 8 M(:,:,3) = 5 6 7 8 ```

Create a vector containing `NaN` values and compute the cumulative minima. By default, `cummin` ignores `NaN` values.

```A = [3 5 NaN 9 0 NaN]; M = cummin(A)```
```M = 1×6 3 3 3 3 0 0 ```

If you include `NaN` values in the calculation, then the cumulative minimum becomes `NaN` as soon as the first `NaN` value in `A` is encountered.

`M = cummin(A,'includenan')`
```M = 1×6 3 3 NaN NaN NaN NaN ```

## Input Arguments

collapse all

Input array, specified as a vector, matrix, or multidimensional array. For complex elements, `cummin` compares the magnitude of the elements. If magnitudes are equal, `cummin` also compares the phase angles.

Data Types: `single` | `double` | `int8` | `int16` | `int32` | `int64` | `uint8` | `uint16` | `uint32` | `uint64` | `logical` | `duration`
Complex Number Support: Yes

Dimension to operate along, specified as a positive integer scalar. If no value is specified, then the default is the first array dimension whose size does not equal 1.

Consider a two-dimensional input array, `A`:

• `cummin(A,1)` works on successive elements in the columns of `A` and returns an array of the same size as `A` with the cumulative minima in each column.

• `cummin(A,2)` works on successive elements in the rows of `A` and returns an array of the same size as `A` with the cumulative minima in each row.

`cummin` returns `A` if `dim` is greater than `ndims(A)`.

Direction of cumulation, specified as `'forward'` (default) or `'reverse'`.

• `'forward'` works from `1` to `end` of the active dimension.

• `'reverse'` works from `end` to `1` of the active dimension.

Data Types: `char`

`NaN` condition, specified as one of the following values:

• `'omitnan'` — Ignore all `NaN` values in the input. If the input has consecutive leading `NaN` values, then `cummin` returns `NaN` in the corresponding elements of the output. For example, ```cummin([NaN 7 13 6],'omitnan')``` returns the row vector ```[NaN 7 7 6]```.

• `'includenan'` — Include `NaN` values from the input when computing the cumulative minima, resulting in `NaN` values in the output.

Data Types: `char`

## Output Arguments

collapse all

Cumulative minima, returned as a vector, matrix, or multidimensional array. The size and data type of `M` are the same as those of `A`.

## Tips

• The `'reverse'` option in many cumulative functions allows quick directional calculations without requiring a flip or reflection of the input array.