arkouda.array_api.statistical_functions
=======================================

.. py:module:: arkouda.array_api.statistical_functions


Functions
---------

.. autoapisummary::

   arkouda.array_api.statistical_functions.cumulative_sum
   arkouda.array_api.statistical_functions.max
   arkouda.array_api.statistical_functions.mean
   arkouda.array_api.statistical_functions.mean_shim
   arkouda.array_api.statistical_functions.min
   arkouda.array_api.statistical_functions.prod
   arkouda.array_api.statistical_functions.std
   arkouda.array_api.statistical_functions.sum
   arkouda.array_api.statistical_functions.var


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

.. py:function:: cumulative_sum(x: arkouda.array_api.array_object.Array, /, *, axis: Optional[int] = None, dtype: Optional[arkouda.array_api._typing.Dtype] = None, include_initial: bool = False) -> arkouda.array_api.array_object.Array

   Compute the cumulative sum of the elements of an array along a given axis.

   :param x: The array to compute the cumulative sum of
   :type x: Array
   :param axis: The axis along which to compute the cumulative sum. If x is 1D, this argument is optional,
                otherwise it is required.
   :type axis: int, optional
   :param dtype: The dtype of the returned array. If None, the dtype of the input array is used.
   :type dtype: Dtype, optional
   :param include_initial: Whether to include the initial value as the first element of the output.
   :type include_initial: bool, optional


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

   Compute the maximum values of an array along a given axis or axes.

   :param x: The array to compute the maximum of
   :type x: Array
   :param axis: The axis or axes along which to compute the maximum values. If None, the maximum value of the
                entire array is computed (returning a scalar-array).
   :type axis: int or Tuple[int, ...], optional
   :param keepdims: Whether to keep the singleton dimension(s) along `axis` in the result.
   :type keepdims: bool, optional


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

   Compute the minimum values of an array along a given axis or axes.

   :param x: The array to compute the minimum of
   :type x: Array
   :param axis: The axis or axes along which to compute the mean. If None, the mean of the entire array is
                computed (returning a scalar-array).
   :type axis: int or Tuple[int, ...], optional
   :param keepdims: Whether to keep the singleton dimension(s) along `axis` in the result.
   :type keepdims: bool, optional


.. py:function:: mean_shim(x: arkouda.array_api.array_object.Array, axis=None, dtype=None, out=None, keepdims=False)

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

   Compute the mean of an array along a given axis or axes.

   :param x: The array to compute the mean of
   :type x: Array
   :param axis: The axis or axes along which to compute the minimum values. If None, the minimum of the entire
                array is computed (returning a scalar-array).
   :type axis: int or Tuple[int, ...], optional
   :param keepdims: Whether to keep the singleton dimension(s) along `axis` in the result.
   :type keepdims: bool, optional


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

   Compute the product of an array along a given axis or axes.

   :param x: The array to compute the product of
   :type x: Array
   :param axis: The axis or axes along which to compute the product. If None, the product of the entire array
                is computed (returning a scalar-array).
   :type axis: int or Tuple[int, ...], optional
   :param dtype: The dtype of the returned array. If None, the dtype of the input array is used.
   :type dtype: Dtype, optional
   :param keepdims: Whether to keep the singleton dimension(s) along `axis` in the result.
   :type keepdims: bool, optional


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

   Compute the standard deviation of an array along a given axis or axes.

   :param x: The array to compute the standard deviation of
   :type x: Array
   :param axis: The axis or axes along which to compute the standard deviation. If None, the standard deviation
                of the entire array is computed (returning a scalar-array).
   :type axis: int or Tuple[int, ...], optional
   :param correction: The degrees of freedom correction to apply. The default is 0.
   :type correction: int or float, optional
   :param keepdims: Whether to keep the singleton dimension(s) along `axis` in the result.
   :type keepdims: bool, optional


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

   Compute the sum of an array along a given axis or axes.

   :param x: The array to compute the sum of
   :type x: Array
   :param axis: The axis or axes along which to compute the sum. If None, the sum of the entire array is
                computed (returning a scalar-array).
   :type axis: int or Tuple[int, ...], optional
   :param dtype: The dtype of the returned array. If None, the dtype of the input array is used.
   :type dtype: Dtype, optional
   :param keepdims: Whether to keep the singleton dimension(s) along `axis` in the result.
   :type keepdims: bool, optional


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

   Compute the variance of an array along a given axis or axes.

   :param x: The array to compute the variance of
   :type x: Array
   :param axis: The axis or axes along which to compute the variance. If None, the variance of the entire array
                is computed (returning a scalar-array).
   :type axis: int or Tuple[int, ...], optional
   :param correction: The degrees of freedom correction to apply. The default is 0.
   :type correction: int or float, optional
   :param keepdims: Whether to keep the singleton dimension(s) along `axis` in the result.
   :type keepdims: bool, optional