# std

Standard deviation

## Syntax

``S = std(A)``
``S = std(A,w)``
``S = std(A,w,'all')``
``S = std(A,w,dim)``
``S = std(A,w,vecdim)``
``S = std(___,nanflag)``

## Description

example

````S = std(A)` returns the standard deviation of the elements of `A` along the first array dimension whose size does not equal 1. If `A` is a vector of observations, then the standard deviation is a scalar. If `A` is a matrix whose columns are random variables and whose rows are observations, then `S` is a row vector containing the standard deviations corresponding to each column.If `A` is a multidimensional array, then `std(A)` operates along the first array dimension whose size does not equal 1, treating the elements as vectors. The size of this dimension becomes `1` while the sizes of all other dimensions remain the same.By default, the standard deviation is normalized by `N-1`, where `N` is the number of observations. ```

example

````S = std(A,w)` specifies a weighting scheme for any of the previous syntaxes. When ```w = 0``` (default), `S` is normalized by `N-1`. When `w = 1`, `S` is normalized by the number of observations, `N`. `w` also can be a weight vector containing nonnegative elements. In this case, the length of `w` must equal the length of the dimension over which `std` is operating. ```
````S = std(A,w,'all')` computes the standard deviation over all elements of `A` when `w` is either 0 or 1. This syntax is valid for MATLAB® versions R2018b and later.```

example

````S = std(A,w,dim)` returns the standard deviation along dimension `dim` for any of the previous syntaxes. To maintain the default normalization while specifying the dimension of operation, set `w = 0` in the second argument.```

example

````S = std(A,w,vecdim)` computes the standard deviation over the dimensions specified in the vector `vecdim` when `w` is 0 or 1. For example, if `A` is a matrix, then `std(A,0,[1 2])` computes the standard deviation over all elements in `A`, since every element of a matrix is contained in the array slice defined by dimensions 1 and 2.```

example

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

## Examples

collapse all

Create a matrix and compute the standard deviation of each column.

```A = [4 -5 1; 2 3 5; -9 1 7]; S = std(A)```
```S = 1×3 7.0000 4.1633 3.0551 ```

Create a 3-D array and compute the standard deviation along the first dimension.

```A(:,:,1) = [2 4; -2 1]; A(:,:,2) = [9 13; -5 7]; A(:,:,3) = [4 4; 8 -3]; S = std(A)```
```S = S(:,:,1) = 2.8284 2.1213 S(:,:,2) = 9.8995 4.2426 S(:,:,3) = 2.8284 4.9497 ```

Create a matrix and compute the standard deviation of each column according to a weight vector `w`.

```A = [1 5; 3 7; -9 2]; w = [1 1 0.5]; S = std(A,w)```
```S = 1×2 4.4900 1.8330 ```

Create a matrix and calculate the standard deviation along each row.

```A = [6 4 23 -3; 9 -10 4 11; 2 8 -5 1]; S = std(A,0,2)```
```S = 3×1 11.0303 9.4692 5.3229 ```

Create a 3-D array and compute the standard deviation over each page of data (rows and columns).

```A(:,:,1) = [2 4; -2 1]; A(:,:,2) = [9 13; -5 7]; A(:,:,3) = [4 4; 8 -3]; S = std(A,0,[1 2])```
```S = S(:,:,1) = 2.5000 S(:,:,2) = 7.7460 S(:,:,3) = 4.5735 ```

Create a vector and compute its standard deviation, excluding `NaN` values.

```A = [1.77 -0.005 3.98 -2.95 NaN 0.34 NaN 0.19]; S = std(A,'omitnan')```
```S = 2.2797 ```

## Input Arguments

collapse all

Input array, specified as a vector, matrix, or multidimensional array. If `A` is a scalar, then `std(A)` returns `0`. If `A` is a `0`-by-`0` empty array, then `std(A)` returns `NaN`.

Data Types: `single` | `double` | `datetime` | `duration`
Complex Number Support: Yes

Weight, specified as one of these values:

• `0` — Normalize by `N-1`, where `N` is the number of observations. If there is only one observation, then the weight is 1.

• `1` — Normalize by `N`.

• Vector made up of nonnegative scalar weights corresponding to the dimension of `A` along which the standard deviation is calculated.

Data Types: `single` | `double`

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.

Dimension `dim` indicates the dimension whose length reduces to `1`. The `size(S,dim)` is `1`, while the sizes of all other dimensions remain the same.

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

• If `dim = 1`, then `std(A,0,1)` returns a row vector containing the standard deviation of the elements in each column. • If `dim = 2`, then `std(A,0,2)` returns a column vector containing the standard deviation of the elements in each row. If `dim` is greater than `ndims(A)`, then `std(A)` returns an array of zeros the same size as `A`.

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

Vector of dimensions, specified as a vector of positive integers. Each element represents a dimension of the input array. The lengths of the output in the specified operating dimensions are 1, while the others remain the same.

Consider a 2-by-3-by-3 input array, `A`. Then `std(A,0,[1 2])` returns a 1-by-1-by-3 array whose elements are the standard deviations computed over each page of `A`. Data Types: `double` | `single` | `int8` | `int16` | `int32` | `int64` | `uint8` | `uint16` | `uint32` | `uint64`

`NaN` condition, specified as one of these values:

• `'includenan'` — Include `NaN` values when computing the standard deviation, resulting in `NaN`.

• `'omitnan'` — Ignore `NaN` values appearing in either the input array or weight vector.

For `datetime` arrays, you can also use `'omitnat'` or `'includenat'` to omit and include `NaT` values, respectively.

Data Types: `char`

collapse all

### Standard Deviation

For a random variable vector A made up of N scalar observations, the standard deviation is defined as

`$\begin{array}{l}S={\sqrt{\frac{1}{N-1}\sum _{i=1}^{N}|{A}_{i}-\mu {|}^{2}}}^{},\hfill \\ \hfill \end{array}$`

where μ is the mean of A:

`$\mu =\frac{1}{N}\sum _{i=1}^{N}{A}_{i}.$`

The standard deviation is the square root of the variance. Some definitions of standard deviation use a normalization factor of N instead of N-1, which you can specify by setting `w` to `1`.