fast_array_utils.stats#

Statistics utilities for 2D arrays.

All of these allow you to specify an axis, which allows you to choose whether to compute the statistic across rows, columns, or all elements.

fast_array_utils.stats.is_constant(x: NDArray[Any] | csc_matrix | csr_matrix | csc_array | csr_array | ndarray, /, *, axis: None = None) → bool#
fast_array_utils.stats.is_constant(x: NDArray[Any] | csc_matrix | csr_matrix | csc_array | csr_array, /, *, axis: Literal[0, 1]) → NDArray[bool]
fast_array_utils.stats.is_constant(x: ndarray, /, *, axis: Literal[0, 1]) → ndarray
fast_array_utils.stats.is_constant(x: Array, /, *, axis: Literal[0, 1] | None = None) → Array
fast_array_utils.stats.is_constant(x: A, /, *, axis: Literal[0, 1] | None = None) → bool | A

Check whether values in array are constant.

Parameters:
x

Array to check.

axis

Axis to reduce over.

Returns:

If axis is None, return if all values were constant. Else returns a boolean array with True representing constant columns/rows.

Example

>>> import numpy as np
>>> x = np.array([
...     [0, 1, 2],
...     [0, 0, 0],
... ])
>>> is_constant(x)
False
>>> is_constant(x, axis=0)
array([ True, False, False])
>>> is_constant(x, axis=1)
array([False,  True])
fast_array_utils.stats.max(x: CpuArray | DiskArray, /, *, axis: None = None, keep_cupy_as_array: bool = False) → number[Any]#
fast_array_utils.stats.max(x: CpuArray | DiskArray, /, *, axis: Literal[0, 1], keep_cupy_as_array: bool = False) → NDArray[Any]
fast_array_utils.stats.max(x: GpuArray, /, *, axis: None = None, keep_cupy_as_array: Literal[False] = False) → number[Any]
fast_array_utils.stats.max(x: GpuArray, /, *, axis: None, keep_cupy_as_array: Literal[True]) → ndarray
fast_array_utils.stats.max(x: GpuArray, /, *, axis: Literal[0, 1], keep_cupy_as_array: bool = False) → ndarray
fast_array_utils.stats.max(x: Array, /, *, axis: Literal[0, 1] | None = None, keep_cupy_as_array: bool = False) → Array
fast_array_utils.stats.max(x: A, /, *, axis: Literal[0, 1] | None = None, keep_cupy_as_array: bool = False) → A

Find the maximum along both or one axis.

Parameters:
x

Array to find the maximum(s) in.

axis

Axis to reduce over.

Returns:

If axis is None, then the maximum element is returned as a scalar. Otherwise, the maximum along the given axis is returned as a 1D array.

Example

>>> import numpy as np
>>> x = np.array([
...     [0, 1, 2],
...     [0, 0, 0],
... ])
>>> max(x)
np.int64(2)
>>> max(x, axis=0)
array([0, 1, 2])
>>> max(x, axis=1)
array([2, 0])

See also

numpy.max()

fast_array_utils.stats.mean(x: CpuArray | GpuArray | DiskArray, /, *, axis: None = None, dtype: DTypeLike | None = None) → number[Any]#
fast_array_utils.stats.mean(x: CpuArray | DiskArray, /, *, axis: Literal[0, 1], dtype: DTypeLike | None = None) → NDArray[number[Any]]
fast_array_utils.stats.mean(x: GpuArray, /, *, axis: Literal[0, 1], dtype: DTypeLike | None = None) → ndarray
fast_array_utils.stats.mean(x: Array, /, *, axis: Literal[0, 1], dtype: ToDType[Any] | None = None) → Array
fast_array_utils.stats.mean(x: A, /, *, axis: Literal[0, 1] | None = None, dtype: DTypeLike | None = None) → A

Mean over both or one axis.

Parameters:
x

Array to calculate mean(s) for.

axis

Axis to reduce over.

Returns:

If axis is None, then the sum over all elements is returned as a scalar. Otherwise, the sum over the given axis is returned as a 1D array.

Example

>>> import numpy as np
>>> x = np.array([
...     [0, 1, 2],
...     [0, 0, 0],
... ])
>>> mean(x)
np.float64(0.5)
>>> mean(x, axis=0)
array([0. , 0.5, 1. ])
>>> mean(x, axis=1)
array([1., 0.])

See also

numpy.mean()

fast_array_utils.stats.mean_var(x: CpuArray | GpuArray, /, *, axis: None = None, correction: int = 0) → tuple[float64, float64]#
fast_array_utils.stats.mean_var(x: CpuArray, /, *, axis: Literal[0, 1], correction: int = 0) → tuple[NDArray[float64], NDArray[float64]]
fast_array_utils.stats.mean_var(x: GpuArray, /, *, axis: Literal[0, 1], correction: int = 0) → tuple[ndarray, ndarray]
fast_array_utils.stats.mean_var(x: Array, /, *, axis: Literal[0, 1] | None = None, correction: int = 0) → tuple[Array, Array]
fast_array_utils.stats.mean_var(x: A, /, *, axis: Literal[0, 1] | None = None, correction: int = 0) → tuple[A, A]

Mean and variance over both or one axis.

Parameters:
x

Array to compute mean and variance for.

axis

Axis to reduce over.

correction

Degrees of freedom correction.

Returns:

meanfloat64

See below:

varfloat64

If axis is None, the mean and variance over all elements are returned as scalars. Otherwise, the means and variances over the given axis are returned as 1D arrays.

Example

>>> import numpy as np
>>> x = np.array([
...     [0, 1, 2],
...     [0, 0, 0],
... ])
>>> mean_var(x)
(np.float64(0.5), np.float64(0.5833333333333334))
>>> mean_var(x, axis=0)
(array([0. , 0.5, 1. ]), array([0.  , 0.25, 1.  ]))
>>> mean_var(x, axis=1)
(array([1., 0.]), array([0.66666667, 0.        ]))
fast_array_utils.stats.min(x: CpuArray | DiskArray, /, *, axis: None = None, keep_cupy_as_array: bool = False) → number[Any]#
fast_array_utils.stats.min(x: CpuArray | DiskArray, /, *, axis: Literal[0, 1], keep_cupy_as_array: bool = False) → NDArray[Any]
fast_array_utils.stats.min(x: GpuArray, /, *, axis: None = None, keep_cupy_as_array: Literal[False] = False) → number[Any]
fast_array_utils.stats.min(x: GpuArray, /, *, axis: None, keep_cupy_as_array: Literal[True]) → ndarray
fast_array_utils.stats.min(x: GpuArray, /, *, axis: Literal[0, 1], keep_cupy_as_array: bool = False) → ndarray
fast_array_utils.stats.min(x: Array, /, *, axis: Literal[0, 1] | None = None, keep_cupy_as_array: bool = False) → Array
fast_array_utils.stats.min(x: A, /, *, axis: Literal[0, 1] | None = None, keep_cupy_as_array: bool = False) → A

Find the minimum along both or one axis.

Parameters:
x

Array to find the minimum(s) in.

axis

Axis to reduce over.

Returns:

If axis is None, then the minimum element is returned as a scalar. Otherwise, the minimum along the given axis is returned as a 1D array.

Example

>>> import numpy as np
>>> x = np.array([
...     [0, 1, 2],
...     [1, 1, 1],
... ])
>>> min(x)
np.int64(0)
>>> min(x, axis=0)
array([0, 1, 1])
>>> min(x, axis=1)
array([0, 1])

See also

numpy.min()

fast_array_utils.stats.sum(x: CpuArray | DiskArray, /, *, axis: None = None, dtype: DTypeLike | None = None, keep_cupy_as_array: bool = False) → number[Any]#
fast_array_utils.stats.sum(x: CpuArray | DiskArray, /, *, axis: Literal[0, 1], dtype: DTypeLike | None = None, keep_cupy_as_array: bool = False) → NDArray[Any]
fast_array_utils.stats.sum(x: GpuArray, /, *, axis: None = None, dtype: DTypeLike | None = None, keep_cupy_as_array: Literal[False] = False) → number[Any]
fast_array_utils.stats.sum(x: GpuArray, /, *, axis: None = None, dtype: DTypeLike | None = None, keep_cupy_as_array: Literal[True]) → ndarray
fast_array_utils.stats.sum(x: GpuArray, /, *, axis: Literal[0, 1], dtype: DTypeLike | None = None, keep_cupy_as_array: bool = False) → ndarray
fast_array_utils.stats.sum(x: Array, /, *, axis: Literal[0, 1] | None = None, dtype: DTypeLike | None = None, keep_cupy_as_array: bool = False) → Array
fast_array_utils.stats.sum(x: A, /, *, axis: Literal[0, 1] | None = None, dtype: DTypeLike | None = None, keep_cupy_as_array: bool = False) → A

Sum over both or one axis.

Parameters:
x

Array to sum up.

axis

Axis to reduce over.

Returns:

If axis is None, then the sum over all elements is returned as a scalar. Otherwise, the sum over the given axis is returned as a 1D array.

Example

>>> import numpy as np
>>> x = np.array([
...     [0, 1, 2],
...     [0, 0, 0],
... ])
>>> sum(x)
np.int64(3)
>>> sum(x, axis=0)
array([0, 1, 2])
>>> sum(x, axis=1)
array([3, 0])

See also

numpy.sum()