var

Syntax

``V = var(A)``
``V = var(A,w)``
``V = var(A,w,"all")``
``V = var(A,w,dim)``
``V = var(A,w,vecdim)``
``V = var(___,nanflag)``
``[V,M] = var(___)``

Description

example

````V = var(A)` returns the variance of the elements of `A` along the first array dimension whose size is greater than 1. By default, the variance is normalized by `N-1`, where `N` is the number of observations.If `A` is a vector of observations, then `V` is a scalar.If `A` is a matrix whose columns are random variables and whose rows are observations, then `V` is a row vector containing the variance corresponding to each column.If `A` is a multidimensional array, then `var(A)` operates along the first array dimension whose size is greater than 1, treating the elements as vectors. The size of `V` in this dimension becomes `1`, while the sizes of all other dimensions are the same as in `A`.If `A` is a scalar, then `V` is `0`.If `A` is a `0`-by-`0` empty array, then `V` is `NaN`.If `A` is a table or timetable, then `var(A)` returns a one-row table containing the variance of each variable. (since R2023a)```

example

````V = var(A,w)` specifies a weighting scheme. When `w = 0` (default), the variance is normalized by `N-1`, where `N` is the number of observations. When `w = 1`, the variance is normalized by the number of observations. `w` can also be a weight vector containing nonnegative elements. In this case, the length of `w` must equal the length of the dimension over which `var` is operating. ```
````V = var(A,w,"all")` returns the variance over all elements of `A` when `w` is either 0 or 1.```

example

````V = var(A,w,dim)` returns the variance along dimension `dim`. To maintain the default normalization while specifying the dimension of operation, set ```w = 0``` in the second argument.```

example

````V = var(A,w,vecdim)` returns the variance over the dimensions specified in the vector `vecdim` when `w` is 0 or 1. For example, if `A` is a matrix, then `var(A,0,[1 2])` returns the variance over all elements in `A` because every element of a matrix is contained in the array slice defined by dimensions 1 and 2.```

example

````V = var(___,nanflag)` specifies whether to include or omit `NaN` values in `A` for any of the previous syntaxes. For example, `var(A,"omitnan")` ignores `NaN` values when computing the variance. By default, `var` includes `NaN` values.```

example

````[V,M] = var(___)` also returns the mean of the elements of `A` used to calculate the variance. If `V` is the weighted variance, then `M` is the weighted mean.```

Examples

collapse all

Create a matrix and compute its variance.

```A = [4 -7 3; 1 4 -2; 10 7 9]; var(A)```
```ans = 1×3 21.0000 54.3333 30.3333 ```

Create a 3-D array and compute its variance.

```A(:,:,1) = [1 3; 8 4]; A(:,:,2) = [3 -4; 1 2]; var(A)```
```ans = ans(:,:,1) = 24.5000 0.5000 ans(:,:,2) = 2 18 ```

Create a matrix and compute its variance according to a weight vector `w`.

```A = [5 -4 6; 2 3 9; -1 1 2]; w = [0.5 0.25 0.25]; var(A,w)```
```ans = 1×3 6.1875 9.5000 6.1875 ```

Create a matrix and compute its variance along the first dimension.

```A = [4 -2 1; 9 5 7]; var(A,0,1)```
```ans = 1×3 12.5000 24.5000 18.0000 ```

Compute the variance of `A` along the second dimension.

`var(A,0,2)`
```ans = 2×1 9 4 ```

Create a 3-D array and compute the variance 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]; V = var(A,0,[1 2])```
```V = V(:,:,1) = 6.2500 V(:,:,2) = 60 V(:,:,3) = 20.9167 ```

Create a matrix containing `NaN` values.

`A = [1.77 -0.005 NaN -2.95; NaN 0.34 NaN 0.19]`
```A = 2×4 1.7700 -0.0050 NaN -2.9500 NaN 0.3400 NaN 0.1900 ```

Compute the variance of the matrix, excluding `NaN` values. For matrix columns that contain any `NaN` value, `var` computes with non-`NaN` elements. For matrix columns that contain all `NaN` values, the variance is `NaN`.

`V = var(A,"omitnan")`
```V = 1×4 0 0.0595 NaN 4.9298 ```

Create a matrix and compute the variance and mean of each column.

```A = [4 -7 3; 1 4 -2; 10 7 9]; [V,M] = var(A)```
```V = 1×3 21.0000 54.3333 30.3333 ```
```M = 1×3 5.0000 1.3333 3.3333 ```

Create a matrix and compute the weighted variance and weighted mean of each column according to a weight vector `w`.

```A = [5 -4 6; 2 3 9; -1 1 2]; w = [0.5 0.25 0.25]; [V,M] = var(A,w)```
```V = 1×3 6.1875 9.5000 6.1875 ```
```M = 1×3 2.7500 -1.0000 5.7500 ```

Input Arguments

collapse all

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

Data Types: `single` | `double` | `table` | `timetable`
Complex Number Support: Yes

Weight, specified as one of:

• `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 variance is calculated.

Data Types: `single` | `double`

Dimension to operate along, specified as a positive integer scalar. If you do not specify the dimension, then the default is the first array dimension of size greater than 1.

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

Consider an `m`-by-`n` input matrix, `A`:

• `var(A,0,1)` computes the variance of the elements in each column of `A` and returns a `1`-by-`n` row vector.

• `var(A,0,2)` computes the variance of the elements in each row of `A` and returns an `m`-by-`1` column vector.

If `dim` is greater than `ndims(A)`, then `var(A)` returns an array of zeros the same size as `A`.

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 `var(A,0,[1 2])` returns a 1-by-1-by-3 array whose elements are the variances computed over each page of `A`.

Missing value condition, specified as one of these values:

• `"includemissing"` or `"includenan"` — Include `NaN` values in `A` when computing the variance. If any element in the operating dimension is `NaN`, then the corresponding element in `V` is `NaN`. `"includemissing"` and `"includenan"` have the same behavior.

• `"omitmissing"` or `"omitnan"` — Ignore `NaN` values in `A` and `w`, and compute the variance over fewer points. If all elements in the operating dimension are `NaN`, then the corresponding element in `V` is `NaN`. `"omitmissing"` and `"omitnan"` have the same behavior.

Output Arguments

collapse all

Variance, returned as a scalar, vector, matrix, multidimensional array, or table.

• If `A` is a vector of observations, then `V` is a scalar.

• If `A` is a matrix whose columns are random variables and whose rows are observations, then `V` is a row vector containing the variance corresponding to each column.

• If `A` is a multidimensional array, then `var(A)` operates along the first array dimension whose size is greater than 1, treating the elements as vectors. The size of `V` in this dimension becomes `1`, while the sizes of all other dimensions are the same as in `A`.

• If `A` is a scalar, then `V` is `0`.

• If `A` is a `0`-by-`0` empty array, then `V` is `NaN`.

• If `A` is a table or timetable, then `V` is a one-row table. If the variables of `A` have units, then the variables of `V` do not have those units. (since R2023a)

Mean, returned as a scalar, vector, matrix, multidimensional array, or table.

• If `A` is a vector of observations, then `M` is a scalar.

• If `A` is a matrix whose columns are random variables and whose rows are observations, then `M` is a row vector containing the mean corresponding to each column.

• If `A` is a multidimensional array, then `var(A)` operates along the first array dimension whose size is greater than 1, treating the elements as vectors. The size of `M` in this dimension becomes `1`, while the sizes of all other dimensions are the same as in `A`.

• If `A` is a scalar, then `M` is equal to `A`.

• If `A` is a `0`-by-`0` empty array, then `M` is `NaN`.

• If `A` is a table or timetable, then `M` is a one-row table. If the variables of `A` have units, then the variables of `M` have the same units. (since R2023a)

If `V` is the weighted variance, then `M` is the weighted mean.

collapse all

Variance

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

`$V=\frac{1}{N-1}\sum _{i=1}^{N}|{A}_{i}-\mu {|}^{2}$`

where μ is the mean of A,

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

Some definitions of variance use a normalization factor N instead of N – 1. You can use a normalization factor of N by specifying a weight of `1`, producing the second moment of the sample about its mean.

Regardless of the normalization factor for the variance, the mean is assumed to have the normalization factor N.

Weighted Variance

For a finite-length vector A made up of N scalar observations and weighting scheme `w`, the weighted variance is defined as

`${V}_{w}=\frac{\sum _{i=1}^{N}{w}_{i}|{A}_{i}-{\mu }_{w}{|}^{2}}{\sum _{i=1}^{N}{w}_{i}}$`

where μw is the weighted mean of A.

Weighted Mean

For a finite-length vector A made up of N scalar observations and weighting scheme `w`, the weighted mean is defined as

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

Version History

Introduced before R2006a

expand all