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
axisisNone, return if all values were constant. Else returns a boolean array withTruerepresenting 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
axisisNone, 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
- 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
axisisNone, 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
- 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:
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. ]))
See also
- 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
axisisNone, 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
- 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
axisisNone, 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