Skip to main content
`Ctrl`+`K`

# biweight_midvariance

astropy.stats.biweight.biweight_midvariance(data, c=9.0, M=None, axis=None, modify_sample_size=False, *, ignore_nan=False)

  Compute the biweight midvariance.

  The biweight midvariance is a robust statistic for determining the variance of a distribution. Its square root is a robust estimator of scale (i.e. standard deviation). It is given by:

  \[\zeta_{bivar} = n \ \frac{\sum_{|u_i| < 1} \ (x_i - M)^2 (1 - u_i^2)^4} {(\sum_{|u_i| < 1} \ (1 - u_i^2) (1 - 5u_i^2))^2}\]

  where \(x\) is the input data, \(M\) is the sample median (or the input location) and \(u_i\) is given by:

  \[u_{i} = \frac{(x_i - M)}{c * MAD}\]

  where \(c\) is the tuning constant and \(MAD\) is the median absolute deviation. The biweight midvariance tuning constant `c` is typically 9.0 (the default).

  If \(MAD\) is zero, then zero will be returned.

  For the standard definition of biweight midvariance, \(n\) is the total number of points in the array (or along the input `axis`, if specified). That definition is used if `modify_sample_size` is `False`, which is the default.

  However, if `modify_sample_size = True`, then \(n\) is the number of points for which \(|u_i| < 1\) (i.e. the total number of non-rejected values), i.e.

  \[n = \sum_{|u_i| < 1} \ 1\]

  which results in a value closer to the true variance for small sample sizes or for a large number of rejected values.

  Parameters:
    data numpy:array_like

      Input array or object that can be converted to an array. `data` can be a `MaskedArray`.

    c `python:float`, optional

      Tuning constant for the biweight estimator (default = 9.0).

    M `python:float` or numpy:array_like, optional

      The location estimate. If `M` is a scalar value, then its value will be used for the entire array (or along each `axis`, if specified). If `M` is an array, then its must be an array containing the location estimate along each `axis` of the input array. If `None` (default), then the median of the input array will be used (or along each `axis`, if specified).

    axis `python:int` or `python:tuple` of `python:int`, optional

      The axis or axes along which the biweight midvariances are computed. If `None` (default), then the biweight midvariance of the flattened input array will be computed.

    modify_sample_size bool, optional

      If `False` (default), then the sample size used is the total number of elements in the array (or along the input `axis`, if specified), which follows the standard definition of biweight midvariance. If `True`, then the sample size is reduced to correct for any rejected values (i.e. the sample size used includes only the non-rejected values), which results in a value closer to the true variance for small sample sizes or for a large number of rejected values.

    ignore_nan bool, optional

      Whether to ignore NaN values in the input `data`.

  Returns:
    biweight_midvariance `python:float` or `ndarray`

      The biweight midvariance of the input data. If `axis` is `None` then a scalar will be returned, otherwise a `ndarray` will be returned.

  See also

  `biweight_midcovariance`, `biweight_midcorrelation`, `astropy.stats.mad_std`, `astropy.stats.median_absolute_deviation`

  References

  [1]

  https://en.wikipedia.org/wiki/Robust_measures_of_scale#The_biweight_midvariance

  [2]

  Beers, Flynn, and Gebhardt (1990; AJ 100, 32) (https://ui.adsabs.harvard.edu/abs/1990AJ….100…32B)

  Examples

  Generate random variates from a Gaussian distribution and return the biweight midvariance of the distribution:

      >>> import numpy as np
      >>> from astropy.stats import biweight_midvariance
      >>> rand = np.random.default_rng(12345)
      >>> bivar = biweight_midvariance(rand.standard_normal(1000))
      >>> print(bivar)
      1.0484350639638342