:mod:`heat.array_api._statistical_functions`
============================================
.. py:module:: heat.array_api._statistical_functions


Module Contents
---------------


.. function:: max(x: heat.array_api._array_object.Array, /, *, axis: Optional[Union[int, Tuple[int, Ellipsis]]] = None, keepdims: bool = False) -> heat.array_api._array_object.Array

   Calculates the maximum value of the input array ``x``.

   :param x: Input array. Must have a numeric data type.
   :type x: Array
   :param axis: Axis or axes along which maximum values are computed. By default, the maximum
                value is computed over the entire array. If a tuple of integers, maximum
                values are computed over multiple axes. Default: ``None``.
   :type axis: Optional[Union[int, Tuple[int, ...]]]
   :param keepdims: If ``True``, the reduced axes (dimensions) are included in the result as
                    singleton dimensions. Otherwise, if ``False``, the reduced axes
                    (dimensions) are be included in the result. Default: ``False``.
   :type keepdims: bool


.. function:: mean(x: heat.array_api._array_object.Array, /, *, axis: Optional[Union[int, Tuple[int, Ellipsis]]] = None, keepdims: bool = False) -> heat.array_api._array_object.Array

   Calculates the arithmetic mean of the input array ``x``.

   :param x: Input array. Must have a floating-point data type.
   :type x: Array
   :param axis: Axis or axes along which arithmetic means are computed. By default, the mean
                is computed over the entire array. If a tuple of integers, arithmetic means
                are computed over multiple axes. Default: ``None``.
   :type axis: Optional[Union[int, Tuple[int, ...]]]
   :param keepdims: If ``True``, the reduced axes (dimensions) are included in the result as
                    singleton dimensions. Otherwise, if ``False``, the reduced axes
                    (dimensions) are be included in the result. Default: ``False``.
   :type keepdims: bool


.. function:: min(x: heat.array_api._array_object.Array, /, *, axis: Optional[Union[int, Tuple[int, Ellipsis]]] = None, keepdims: bool = False) -> heat.array_api._array_object.Array

   Calculates the minimum value of the input array ``x``.

   :param x: Input array. Must have a numeric data type.
   :type x: Array
   :param axis: Axis or axes along which minimum  values are computed. By default, the minimum
                value is computed over the entire array. If a tuple of integers, minimum
                values are computed over multiple axes. Default: ``None``.
   :type axis: Optional[Union[int, Tuple[int, ...]]]
   :param keepdims: If ``True``, the reduced axes (dimensions) are included in the result as
                    singleton dimensions. Otherwise, if ``False``, the reduced axes
                    (dimensions) are be included in the result. Default: ``False``.
   :type keepdims: bool


.. function:: prod(x: heat.array_api._array_object.Array, /, *, axis: Optional[Union[int, Tuple[int, Ellipsis]]] = None, dtype: Optional[heat.array_api._typing.Dtype] = None, keepdims: bool = False) -> heat.array_api._array_object.Array

   Calculates the product of input array ``x`` elements.

   :param x: Input array. Must have a numeric data type.
   :type x: Array
   :param axis: Axis or axes along which products are computed. By default, the product is
                computed over the entire array. If a tuple of integers, products are computed
                over multiple axes. Default: ``None``.
   :type axis: Optional[Union[int, Tuple[int, ...]]]
   :param dtype: Data type of the returned array.
   :type dtype: Optional[Dtype]
   :param keepdims: If ``True``, the reduced axes (dimensions) are included in the result as
                    singleton dimensions. Otherwise, if ``False``, the reduced axes
                    (dimensions) are be included in the result. Default: ``False``.
   :type keepdims: bool


.. function:: std(x: heat.array_api._array_object.Array, /, *, axis: Optional[Union[int, Tuple[int, Ellipsis]]] = None, correction: Union[int, float] = 0.0, keepdims: bool = False) -> heat.array_api._array_object.Array

   Calculates the standard deviation of the input array ``x``.

   :param x: Input array. Must have a floating-point data type.
   :type x: Array
   :param axis: Axis or axes along which standard deviations are computed. By default, the
                standard deviation is computed over the entire array. If a tuple of integers,
                standard deviations are computed over multiple axes. Default: ``None``.
   :type axis: Optional[Union[int, Tuple[int, ...]]]
   :param correction: Degrees of freedom adjustment.
   :type correction: Union[int, float]
   :param keepdims: If ``True``, the reduced axes (dimensions) are included in the result as
                    singleton dimensions. Otherwise, if ``False``, the reduced axes
                    (dimensions) are be included in the result. Default: ``False``.
   :type keepdims: bool


.. function:: sum(x: heat.array_api._array_object.Array, /, *, axis: Optional[Union[int, Tuple[int, Ellipsis]]] = None, dtype: Optional[heat.array_api._typing.Dtype] = None, keepdims: bool = False) -> heat.array_api._array_object.Array

   Calculates the sum of the input array ``x``.

   :param x: Input array. Must have a numeric data type.
   :type x: Array
   :param axis: Axis or axes along which sums are computed. By default, the sum is
                computed over the entire array. If a tuple of integers, sums are computed
                over multiple axes. Default: ``None``.
   :type axis: Optional[Union[int, Tuple[int, ...]]]
   :param dtype: Data type of the returned array.
   :type dtype: Optional[Dtype]
   :param keepdims: If ``True``, the reduced axes (dimensions) are included in the result as
                    singleton dimensions. Otherwise, if ``False``, the reduced axes
                    (dimensions) are be included in the result. Default: ``False``.
   :type keepdims: bool


.. function:: var(x: heat.array_api._array_object.Array, /, *, axis: Optional[Union[int, Tuple[int, Ellipsis]]] = None, correction: Union[int, float] = 0.0, keepdims: bool = False) -> heat.array_api._array_object.Array

   Calculates the variance of the input array ``x``.

   :param x: Input array. Must have a floating-point data type.
   :type x: Array
   :param axis: Axis or axes along which variances are computed. By default, the
                variance is computed over the entire array. If a tuple of integers,
                variances are computed over multiple axes. Default: ``None``.
   :type axis: Optional[Union[int, Tuple[int, ...]]]
   :param correction: Degrees of freedom adjustment.
   :type correction: Union[int, float]
   :param keepdims: If ``True``, the reduced axes (dimensions) are included in the result as
                    singleton dimensions. Otherwise, if ``False``, the reduced axes
                    (dimensions) are be included in the result. Default: ``False``.
   :type keepdims: bool