### `numpy.array(...)`

array(object, dtype=None, *, copy=True, order='K', subok=False, ndmin=0,
like=None)

Create an array.

Parameters
----------
object : array_like
An array, any object exposing the array interface, an object whose
``__array__`` method returns an array, or any (nested) sequence.
If object is a scalar, a 0-dimensional array containing object is
returned.
dtype : data-type, optional
The desired data-type for the array. If not given, NumPy will try to use
a default ``dtype`` that can represent the values (by applying promotion
rules when necessary.)
copy : bool, optional
If ``True`` (default), then the array data is copied. If ``None``,
a copy will only be made if ``__array__`` returns a copy, if obj is
a nested sequence, or if a copy is needed to satisfy any of the other
requirements (``dtype``, ``order``, etc.). Note that any copy of
the data is shallow, i.e., for arrays with object dtype, the new
array will point to the same objects. See Examples for `ndarray.copy`.
For ``False`` it raises a ``ValueError`` if a copy cannot be avoided.
Default: ``True``.
order : {'K', 'A', 'C', 'F'}, optional
Specify the memory layout of the array. If object is not an array, the
newly created array will be in C order (row major) unless 'F' is
specified, in which case it will be in Fortran order (column major).
If object is an array the following holds.

    ===== ========= ===================================================
    order  no copy                     copy=True
    ===== ========= ===================================================
    'K'   unchanged F & C order preserved, otherwise most similar order
    'A'   unchanged F order if input is F and not C, otherwise C order
    'C'   C order   C order
    'F'   F order   F order
    ===== ========= ===================================================

    When ``copy=None`` and a copy is made for other reasons, the result is
    the same as if ``copy=True``, with some exceptions for 'A', see the
    Notes section. The default order is 'K'.

subok : bool, optional
If True, then sub-classes will be passed-through, otherwise
the returned array will be forced to be a base-class array (default).
ndmin : int, optional
Specifies the minimum number of dimensions that the resulting
array should have. Ones will be prepended to the shape as
needed to meet this requirement.
like : array_like, optional
Reference object to allow the creation of arrays which are not
NumPy arrays. If an array-like passed in as ``like`` supports
the ``__array_function__`` protocol, the result will be defined
by it. In this case, it ensures the creation of an array object
compatible with that passed in via this argument.

    .. versionadded:: 1.20.0

Returns
-------
out : ndarray
An array object satisfying the specified requirements.

See Also
--------
empty_like : Return an empty array with shape and type of input.
ones_like : Return an array of ones with shape and type of input.
zeros_like : Return an array of zeros with shape and type of input.
full_like : Return a new array with shape of input filled with value.
empty : Return a new uninitialized array.
ones : Return a new array setting values to one.
zeros : Return a new array setting values to zero.
full : Return a new array of given shape filled with value.
copy: Return an array copy of the given object.


Notes
-----
When order is 'A' and ``object`` is an array in neither 'C' nor 'F' order,
and a copy is forced by a change in dtype, then the order of the result is
not necessarily 'C' as expected. This is likely a bug.

Examples
--------
> > > import numpy as np
> > > np.array([1, 2, 3])
> > > array([1, 2, 3])

Upcasting:

> > > np.array([1, 2, 3.0])
> > > array([ 1., 2., 3.])

More than one dimension:

> > > np.array([[1, 2], [3, 4]])
> > > array([[1, 2],
[3, 4]])

Minimum dimensions 2:

> > > np.array([1, 2, 3], ndmin=2)
> > > array([[1, 2, 3]])

Type provided:

> > > np.array([1, 2, 3], dtype=complex)
> > > array([ 1.+0.j, 2.+0.j, 3.+0.j])

Data-type consisting of more than one element:

> > > x = np.array([(1,2),(3,4)],dtype=[('a','<i4'),('b','<i4')])
> > > x['a']
> > > array([1, 3], dtype=int32)

Creating an array from sub-classes:

> > > np.array(np.asmatrix('1 2; 3 4'))
> > > array([[1, 2],
[3, 4]])

> > > np.array(np.asmatrix('1 2; 3 4'), subok=True)
> > > matrix([[1, 2],
[3, 4]])

---

### `numpy.arange(...)`

arange([start,] stop[, step,], dtype=None, *, device=None, like=None)

Return evenly spaced values within a given interval.

``arange`` can be called with a varying number of positional arguments:

* ``arange(stop)``: Values are generated within the half-open interval
  ``[0, stop)`` (in other words, the interval including `start` but
  excluding `stop`).
* ``arange(start, stop)``: Values are generated within the half-open
  interval ``[start, stop)``.
* ``arange(start, stop, step)`` Values are generated within the half-open
  interval ``[start, stop)``, with spacing between values given by
  ``step``.

For integer arguments the function is roughly equivalent to the Python
built-in :py:class:`range`, but returns an ndarray rather than a ``range``
instance.

When using a non-integer step, such as 0.1, it is often better to use
`numpy.linspace`.

See the Warning sections below for more information.

Parameters
----------
start : integer or real, optional
Start of interval. The interval includes this value. The default
start value is 0.
stop : integer or real
End of interval. The interval does not include this value, except
in some cases where `step` is not an integer and floating point
round-off affects the length of `out`.
step : integer or real, optional
Spacing between values. For any output `out`, this is the distance
between two adjacent values, ``out[i+1] - out[i]``. The default
step size is 1. If `step` is specified as a position argument,
`start` must also be given.
dtype : dtype, optional
The type of the output array. If `dtype` is not given, infer the data
type from the other input arguments.
device : str, optional
The device on which to place the created array. Default: ``None``.
For Array-API interoperability only, so must be ``"cpu"`` if passed.

    .. versionadded:: 2.0.0

like : array_like, optional
Reference object to allow the creation of arrays which are not
NumPy arrays. If an array-like passed in as ``like`` supports
the ``__array_function__`` protocol, the result will be defined
by it. In this case, it ensures the creation of an array object
compatible with that passed in via this argument.

    .. versionadded:: 1.20.0

Returns
-------
arange : ndarray
Array of evenly spaced values.

    For floating point arguments, the length of the result is
    ``ceil((stop - start)/step)``.  Because of floating point overflow,
    this rule may result in the last element of `out` being greater
    than `stop`.

Warnings
--------
The length of the output might not be numerically stable.

Another stability issue is due to the internal implementation of
`numpy.arange`.
The actual step value used to populate the array is
``dtype(start + step) - dtype(start)`` and not `step`. Precision loss
can occur here, due to casting or due to using floating points when
`start` is much larger than `step`. This can lead to unexpected
behaviour. For example::

> > > np.arange(0, 5, 0.5, dtype=int)
> > > array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
> > > np.arange(-3, 3, 0.5, dtype=int)
> > > array([-3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8])

In such cases, the use of `numpy.linspace` should be preferred.

The built-in :py:class:`range` generates :std:doc:`Python built-in integers
that have arbitrary size <python:c-api/long>`, while `numpy.arange`
produces `numpy.int32` or `numpy.int64` numbers. This may result in
incorrect results for large integer values::

> > > power = 40
> > > modulo = 10000
> > > x1 = [(n ** power) % modulo for n in range(8)]
> > > x2 = [(n ** power) % modulo for n in np.arange(8)]
> > > print(x1)
[0, 1, 7776, 8801, 6176, 625, 6576, 4001]  # correct
> > > print(x2)
[0, 1, 7776, 7185, 0, 5969, 4816, 3361]  # incorrect

See Also
--------
numpy.linspace : Evenly spaced numbers with careful handling of endpoints.
numpy.ogrid: Arrays of evenly spaced numbers in N-dimensions.
numpy.mgrid: Grid-shaped arrays of evenly spaced numbers in N-dimensions.
:ref:`how-to-partition`

Examples
--------
> > > import numpy as np
> > > np.arange(3)
> > > array([0, 1, 2])
> > > np.arange(3.0)
> > > array([ 0., 1., 2.])
> > > np.arange(3,7)
> > > array([3, 4, 5, 6])
> > > np.arange(3,7,2)
> > > array([3, 5])

---

### `numpy.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None, axis=0, *, device=None)`

Return evenly spaced numbers over a specified interval.

Returns `num` evenly spaced samples, calculated over the
interval [`start`, `stop`].

The endpoint of the interval can optionally be excluded.

.. versionchanged:: 1.20.0
Values are rounded towards ``-inf`` instead of ``0`` when an
integer ``dtype`` is specified. The old behavior can
still be obtained with ``np.linspace(start, stop, num).astype(int)``

Parameters
----------
start : array_like
The starting value of the sequence.
stop : array_like
The end value of the sequence, unless `endpoint` is set to False.
In that case, the sequence consists of all but the last of ``num + 1``
evenly spaced samples, so that `stop` is excluded. Note that the step
size changes when `endpoint` is False.
num : int, optional
Number of samples to generate. Default is 50. Must be non-negative.
endpoint : bool, optional
If True, `stop` is the last sample. Otherwise, it is not included.
Default is True.
retstep : bool, optional
If True, return (`samples`, `step`), where `step` is the spacing
between samples.
dtype : dtype, optional
The type of the output array. If `dtype` is not given, the data type
is inferred from `start` and `stop`. The inferred dtype will never be
an integer; `float` is chosen even if the arguments would produce an
array of integers.
axis : int, optional
The axis in the result to store the samples. Relevant only if start
or stop are array-like. By default (0), the samples will be along a
new axis inserted at the beginning. Use -1 to get an axis at the end.
device : str, optional
The device on which to place the created array. Default: None.
For Array-API interoperability only, so must be ``"cpu"`` if passed.

    .. versionadded:: 2.0.0

Returns
-------
samples : ndarray
There are `num` equally spaced samples in the closed interval
``[start, stop]`` or the half-open interval ``[start, stop)``
(depending on whether `endpoint` is True or False).
step : float, optional
Only returned if `retstep` is True

    Size of spacing between samples.

See Also
--------
arange : Similar to `linspace`, but uses a step size (instead of the
number of samples).
geomspace : Similar to `linspace`, but with numbers spaced evenly on a log
scale (a geometric progression).
logspace : Similar to `geomspace`, but with the end points specified as
logarithms.
:ref:`how-to-partition`

Examples
--------
> > > import numpy as np
> > > np.linspace(2.0, 3.0, num=5)
> > > array([2. , 2.25, 2.5 , 2.75, 3.  ])
> > > np.linspace(2.0, 3.0, num=5, endpoint=False)
> > > array([2. , 2.2, 2.4, 2.6, 2.8])
> > > np.linspace(2.0, 3.0, num=5, retstep=True)
(array([2. , 2.25, 2.5 , 2.75, 3.  ]), 0.25)

Graphical illustration:

> > > import matplotlib.pyplot as plt
> > > N = 8
> > > y = np.zeros(N)
> > > x1 = np.linspace(0, 10, N, endpoint=True)
> > > x2 = np.linspace(0, 10, N, endpoint=False)
> > > plt.plot(x1, y, 'o')
[<matplotlib.lines.Line2D object at 0x...>]
> > > plt.plot(x2, y + 0.5, 'o')
[<matplotlib.lines.Line2D object at 0x...>]
> > > plt.ylim([-0.5, 1])
(-0.5, 1)
> > > plt.show()

---

### `numpy.reshape(a, /, shape=None, order='C', *, newshape=None, copy=None)`

Gives a new shape to an array without changing its data.

Parameters
----------
a : array_like
Array to be reshaped.
shape : int or tuple of ints
The new shape should be compatible with the original shape. If
an integer, then the result will be a 1-D array of that length.
One shape dimension can be -1. In this case, the value is
inferred from the length of the array and remaining dimensions.
order : {'C', 'F', 'A'}, optional
Read the elements of ``a`` using this index order, and place the
elements into the reshaped array using this index order. 'C'
means to read / write the elements using C-like index order,
with the last axis index changing fastest, back to the first
axis index changing slowest. 'F' means to read / write the
elements using Fortran-like index order, with the first index
changing fastest, and the last index changing slowest. Note that
the 'C' and 'F' options take no account of the memory layout of
the underlying array, and only refer to the order of indexing.
'A' means to read / write the elements in Fortran-like index
order if ``a`` is Fortran *contiguous* in memory, C-like order
otherwise.
newshape : int or tuple of ints
.. deprecated:: 2.1
Replaced by ``shape`` argument. Retained for backward
compatibility.
copy : bool, optional
If ``True``, then the array data is copied. If ``None``, a copy will
only be made if it's required by ``order``. For ``False`` it raises
a ``ValueError`` if a copy cannot be avoided. Default: ``None``.

Returns
-------
reshaped_array : ndarray
This will be a new view object if possible; otherwise, it will
be a copy. Note there is no guarantee of the *memory layout* (C- or
Fortran- contiguous) of the returned array.

See Also
--------
ndarray.reshape : Equivalent method.

Notes
-----
It is not always possible to change the shape of an array without copying
the data.

The ``order`` keyword gives the index ordering both for *fetching*
the values from ``a``, and then *placing* the values into the output
array. For example, let's say you have an array:

> > > a = np.arange(6).reshape((3, 2))
> > > a
> > > array([[0, 1],
[2, 3],
[4, 5]])

You can think of reshaping as first raveling the array (using the given
index order), then inserting the elements from the raveled array into the
new array using the same kind of index ordering as was used for the
raveling.

> > > np.reshape(a, (2, 3)) # C-like index ordering
> > > array([[0, 1, 2],
[3, 4, 5]])
> > > np.reshape(np.ravel(a), (2, 3)) # equivalent to C ravel then C reshape
> > > array([[0, 1, 2],
[3, 4, 5]])
> > > np.reshape(a, (2, 3), order='F') # Fortran-like index ordering
> > > array([[0, 4, 3],
[2, 1, 5]])
> > > np.reshape(np.ravel(a, order='F'), (2, 3), order='F')
> > > array([[0, 4, 3],
[2, 1, 5]])

Examples
--------
> > > import numpy as np
> > > a = np.array([[1,2,3], [4,5,6]])
> > > np.reshape(a, 6)
> > > array([1, 2, 3, 4, 5, 6])
> > > np.reshape(a, 6, order='F')
> > > array([1, 4, 2, 5, 3, 6])

> > > np.reshape(a, (3,-1))       # the unspecified value is inferred to be 2
> > > array([[1, 2],
[3, 4],
[5, 6]])

---

### `numpy.concatenate(...)`

concatenate(
(a1, a2, ...),
axis=0,
out=None,
dtype=None,
casting="same_kind"
)

Join a sequence of arrays along an existing axis.

Parameters
----------
a1, a2, ... : sequence of array_like
The arrays must have the same shape, except in the dimension
corresponding to `axis` (the first, by default).
axis : int, optional
The axis along which the arrays will be joined. If axis is None,
arrays are flattened before use. Default is 0.
out : ndarray, optional
If provided, the destination to place the result. The shape must be
correct, matching that of what concatenate would have returned if no
out argument were specified.
dtype : str or dtype
If provided, the destination array will have this dtype. Cannot be
provided together with `out`.

    .. versionadded:: 1.20.0

casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
Controls what kind of data casting may occur. Defaults to 'same_kind'.
For a description of the options, please see :term:`casting`.

    .. versionadded:: 1.20.0

Returns
-------
res : ndarray
The concatenated array.

See Also
--------
ma.concatenate : Concatenate function that preserves input masks.
array_split : Split an array into multiple sub-arrays of equal or
near-equal size.
split : Split array into a list of multiple sub-arrays of equal size.
hsplit : Split array into multiple sub-arrays horizontally (column wise).
vsplit : Split array into multiple sub-arrays vertically (row wise).
dsplit : Split array into multiple sub-arrays along the 3rd axis (depth).
stack : Stack a sequence of arrays along a new axis.
block : Assemble arrays from blocks.
hstack : Stack arrays in sequence horizontally (column wise).
vstack : Stack arrays in sequence vertically (row wise).
dstack : Stack arrays in sequence depth wise (along third dimension).
column_stack : Stack 1-D arrays as columns into a 2-D array.

Notes
-----
When one or more of the arrays to be concatenated is a MaskedArray,
this function will return a MaskedArray object instead of an ndarray,
but the input masks are *not* preserved. In cases where a MaskedArray
is expected as input, use the ma.concatenate function from the masked
array module instead.

Examples
--------
> > > import numpy as np
> > > a = np.array([[1, 2], [3, 4]])
> > > b = np.array([[5, 6]])
> > > np.concatenate((a, b), axis=0)
> > > array([[1, 2],
[3, 4],
[5, 6]])
> > > np.concatenate((a, b.T), axis=1)
> > > array([[1, 2, 5],
[3, 4, 6]])
> > > np.concatenate((a, b), axis=None)
> > > array([1, 2, 3, 4, 5, 6])

This function will not preserve masking of MaskedArray inputs.

> > > a = np.ma.arange(3)
> > > a[1] = np.ma.masked
> > > b = np.arange(2, 5)
> > > a
> > > masked_array(data=[0, --, 2],
> > > mask=[False, True, False],
> > > fill_value=999999)
> > > b
> > > array([2, 3, 4])
> > > np.concatenate([a, b])
> > > masked_array(data=[0, 1, 2, 2, 3, 4],
> > > mask=False,
> > > fill_value=999999)
> > > np.ma.concatenate([a, b])
> > > masked_array(data=[0, --, 2, 2, 3, 4],
> > > mask=[False, True, False, False, False, False],
> > > fill_value=999999)

---

### `numpy.mean(a, axis=None, dtype=None, out=None, keepdims=<no value>, *, where=<no value>)`

Compute the arithmetic mean along the specified axis.

Returns the average of the array elements. The average is taken over
the flattened array by default, otherwise over the specified axis.
`float64` intermediate and return values are used for integer inputs.

Parameters
----------
a : array_like
Array containing numbers whose mean is desired. If `a` is not an
array, a conversion is attempted.
axis : None or int or tuple of ints, optional
Axis or axes along which the means are computed. The default is to
compute the mean of the flattened array.

    If this is a tuple of ints, a mean is performed over multiple axes,
    instead of a single axis or all the axes as before.

dtype : data-type, optional
Type to use in computing the mean. For integer inputs, the default
is `float64`; for floating point inputs, it is the same as the
input dtype.
out : ndarray, optional
Alternate output array in which to place the result. The default
is ``None``; if provided, it must have the same shape as the
expected output, but the type will be cast if necessary.
See :ref:`ufuncs-output-type` for more details.
See :ref:`ufuncs-output-type` for more details.

keepdims : bool, optional
If this is set to True, the axes which are reduced are left
in the result as dimensions with size one. With this option,
the result will broadcast correctly against the input array.

    If the default value is passed, then `keepdims` will not be
    passed through to the `mean` method of sub-classes of
    `ndarray`, however any non-default value will be.  If the
    sub-class' method does not implement `keepdims` any
    exceptions will be raised.

where : array_like of bool, optional
Elements to include in the mean. See `~numpy.ufunc.reduce` for details.

    .. versionadded:: 1.20.0

Returns
-------
m : ndarray, see dtype parameter above
If `out=None`, returns a new array containing the mean values,
otherwise a reference to the output array is returned.

See Also
--------
average : Weighted average
std, var, nanmean, nanstd, nanvar

Notes
-----
The arithmetic mean is the sum of the elements along the axis divided
by the number of elements.

Note that for floating-point input, the mean is computed using the
same precision the input has. Depending on the input data, this can
cause the results to be inaccurate, especially for `float32` (see
example below). Specifying a higher-precision accumulator using the
`dtype` keyword can alleviate this issue.

By default, `float16` results are computed using `float32` intermediates
for extra precision.

Examples
--------
> > > import numpy as np
> > > a = np.array([[1, 2], [3, 4]])
> > > np.mean(a)
> > > 2.5
> > > np.mean(a, axis=0)
> > > array([2., 3.])
> > > np.mean(a, axis=1)
> > > array([1.5, 3.5])

In single precision, `mean` can be inaccurate:

> > > a = np.zeros((2, 512*512), dtype=np.float32)
> > > a[0, :] = 1.0
> > > a[1, :] = 0.1
> > > np.mean(a)
> > > np.float32(0.54999924)

Computing the mean in float64 is more accurate:

> > > np.mean(a, dtype=np.float64)
> > > 0.55000000074505806 # may vary

Computing the mean in timedelta64 is available:

> > > b = np.array([1, 3], dtype="timedelta64[D]")
> > > np.mean(b)
> > > np.timedelta64(2,'D')

Specifying a where argument:

> > > a = np.array([[5, 9, 13], [14, 10, 12], [11, 15, 19]])
> > > np.mean(a)
> > > 12.0
> > > np.mean(a, where=[[True], [False], [False]])
> > > 9.0

---

###
`numpy.std(a, axis=None, dtype=None, out=None, ddof=0, keepdims=<no value>, *, where=<no value>, mean=<no value>, correction=<no value>)`

Compute the standard deviation along the specified axis.

Returns the standard deviation, a measure of the spread of a distribution,
of the array elements. The standard deviation is computed for the
flattened array by default, otherwise over the specified axis.

Parameters
----------
a : array_like
Calculate the standard deviation of these values.
axis : None or int or tuple of ints, optional
Axis or axes along which the standard deviation is computed. The
default is to compute the standard deviation of the flattened array.
If this is a tuple of ints, a standard deviation is performed over
multiple axes, instead of a single axis or all the axes as before.
dtype : dtype, optional
Type to use in computing the standard deviation. For arrays of
integer type the default is float64, for arrays of float types it is
the same as the array type.
out : ndarray, optional
Alternative output array in which to place the result. It must have
the same shape as the expected output but the type (of the calculated
values) will be cast if necessary.
See :ref:`ufuncs-output-type` for more details.
ddof : {int, float}, optional
Means Delta Degrees of Freedom. The divisor used in calculations
is ``N - ddof``, where ``N`` represents the number of elements.
By default `ddof` is zero. See Notes for details about use of `ddof`.
keepdims : bool, optional
If this is set to True, the axes which are reduced are left
in the result as dimensions with size one. With this option,
the result will broadcast correctly against the input array.

    If the default value is passed, then `keepdims` will not be
    passed through to the `std` method of sub-classes of
    `ndarray`, however any non-default value will be.  If the
    sub-class' method does not implement `keepdims` any
    exceptions will be raised.

where : array_like of bool, optional
Elements to include in the standard deviation.
See `~numpy.ufunc.reduce` for details.

    .. versionadded:: 1.20.0

mean : array_like, optional
Provide the mean to prevent its recalculation. The mean should have
a shape as if it was calculated with ``keepdims=True``.
The axis for the calculation of the mean should be the same as used in
the call to this std function.

    .. versionadded:: 2.0.0

correction : {int, float}, optional
Array API compatible name for the ``ddof`` parameter. Only one of them
can be provided at the same time.

    .. versionadded:: 2.0.0

Returns
-------
standard_deviation : ndarray, see dtype parameter above.
If `out` is None, return a new array containing the standard deviation,
otherwise return a reference to the output array.

See Also
--------
var, mean, nanmean, nanstd, nanvar
:ref:`ufuncs-output-type`

Notes
-----
There are several common variants of the array standard deviation
calculation. Assuming the input `a` is a one-dimensional NumPy array
and ``mean`` is either provided as an argument or computed as
``a.mean()``, NumPy computes the standard deviation of an array as::

    N = len(a)
    d2 = abs(a - mean)**2  # abs is for complex `a`
    var = d2.sum() / (N - ddof)  # note use of `ddof`
    std = var**0.5

Different values of the argument `ddof` are useful in different
contexts. NumPy's default ``ddof=0`` corresponds with the expression:

.. math::

    \sqrt{\frac{\sum_i{|a_i - \bar{a}|^2 }}{N}}

which is sometimes called the "population standard deviation" in the field
of statistics because it applies the definition of standard deviation to
`a` as if `a` were a complete population of possible observations.

Many other libraries define the standard deviation of an array
differently, e.g.:

.. math::

    \sqrt{\frac{\sum_i{|a_i - \bar{a}|^2 }}{N - 1}}

In statistics, the resulting quantity is sometimes called the "sample
standard deviation" because if `a` is a random sample from a larger
population, this calculation provides the square root of an unbiased
estimate of the variance of the population. The use of :math:`N-1` in the
denominator is often called "Bessel's correction" because it corrects for
bias (toward lower values) in the variance estimate introduced when the
sample mean of `a` is used in place of the true mean of the population.
The resulting estimate of the standard deviation is still biased, but less
than it would have been without the correction. For this quantity, use
``ddof=1``.

Note that, for complex numbers, `std` takes the absolute
value before squaring, so that the result is always real and nonnegative.

For floating-point input, the standard deviation is computed using the same
precision the input has. Depending on the input data, this can cause
the results to be inaccurate, especially for float32 (see example below).
Specifying a higher-accuracy accumulator using the `dtype` keyword can
alleviate this issue.

Examples
--------
> > > import numpy as np
> > > a = np.array([[1, 2], [3, 4]])
> > > np.std(a)
> > > 1.1180339887498949 # may vary
> > > np.std(a, axis=0)
> > > array([1., 1.])
> > > np.std(a, axis=1)
> > > array([0.5, 0.5])

In single precision, std() can be inaccurate:

> > > a = np.zeros((2, 512*512), dtype=np.float32)
> > > a[0, :] = 1.0
> > > a[1, :] = 0.1
> > > np.std(a)
> > > np.float32(0.45000005)

Computing the standard deviation in float64 is more accurate:

> > > np.std(a, dtype=np.float64)
> > > 0.44999999925494177 # may vary

Specifying a where argument:

> > > a = np.array([[14, 8, 11, 10], [7, 9, 10, 11], [10, 15, 5, 10]])
> > > np.std(a)
> > > 2.614064523559687 # may vary
> > > np.std(a, where=[[True], [True], [False]])
> > > 2.0

Using the mean keyword to save computation time:

> > > import numpy as np
> > > from timeit import timeit
> > > a = np.array([[14, 8, 11, 10], [7, 9, 10, 11], [10, 15, 5, 10]])
> > > mean = np.mean(a, axis=1, keepdims=True)
>>>
>>> g = globals()
> > > n = 10000
> > > t1 = timeit("std = np.std(a, axis=1, mean=mean)", globals=g, number=n)
> > > t2 = timeit("std = np.std(a, axis=1)", globals=g, number=n)
> > > print(f'Percentage execution time saved {100*(t2-t1)/t2:.0f}%')
> > > #doctest: +SKIP
> > > Percentage execution time saved 30%

---

### `numpy.sum(a, axis=None, dtype=None, out=None, keepdims=<no value>, initial=<no value>, where=<no value>)`

Sum of array elements over a given axis.

Parameters
----------
a : array_like
Elements to sum.
axis : None or int or tuple of ints, optional
Axis or axes along which a sum is performed. The default,
axis=None, will sum all of the elements of the input array. If
axis is negative it counts from the last to the first axis. If
axis is a tuple of ints, a sum is performed on all of the axes
specified in the tuple instead of a single axis or all the axes as
before.
dtype : dtype, optional
The type of the returned array and of the accumulator in which the
elements are summed. The dtype of `a` is used by default unless `a`
has an integer dtype of less precision than the default platform
integer. In that case, if `a` is signed then the platform integer
is used while if `a` is unsigned then an unsigned integer of the
same precision as the platform integer is used.
out : ndarray, optional
Alternative output array in which to place the result. It must have
the same shape as the expected output, but the type of the output
values will be cast if necessary.
keepdims : bool, optional
If this is set to True, the axes which are reduced are left
in the result as dimensions with size one. With this option,
the result will broadcast correctly against the input array.

    If the default value is passed, then `keepdims` will not be
    passed through to the `sum` method of sub-classes of
    `ndarray`, however any non-default value will be.  If the
    sub-class' method does not implement `keepdims` any
    exceptions will be raised.

initial : scalar, optional
Starting value for the sum. See `~numpy.ufunc.reduce` for details.
where : array_like of bool, optional
Elements to include in the sum. See `~numpy.ufunc.reduce` for details.

Returns
-------
sum_along_axis : ndarray
An array with the same shape as `a`, with the specified
axis removed. If `a` is a 0-d array, or if `axis` is None, a scalar
is returned. If an output array is specified, a reference to
`out` is returned.

See Also
--------
ndarray.sum : Equivalent method.
add: ``numpy.add.reduce`` equivalent function.
cumsum : Cumulative sum of array elements.
trapezoid : Integration of array values using composite trapezoidal rule.

mean, average

Notes
-----
Arithmetic is modular when using integer types, and no error is
raised on overflow.

The sum of an empty array is the neutral element 0:

> > > np.sum([])
> > > 0.0

For floating point numbers the numerical precision of sum (and
``np.add.reduce``) is in general limited by directly adding each number
individually to the result causing rounding errors in every step.
However, often numpy will use a numerically better approach (partial
pairwise summation) leading to improved precision in many use-cases.
This improved precision is always provided when no ``axis`` is given.
When ``axis`` is given, it will depend on which axis is summed.
Technically, to provide the best speed possible, the improved precision
is only used when the summation is along the fast axis in memory.
Note that the exact precision may vary depending on other parameters.
In contrast to NumPy, Python's ``math.fsum`` function uses a slower but
more precise approach to summation.
Especially when summing a large number of lower precision floating point
numbers, such as ``float32``, numerical errors can become significant.
In such cases it can be advisable to use `dtype="float64"` to use a higher
precision for the output.

Examples
--------
> > > import numpy as np
> > > np.sum([0.5, 1.5])
> > > 2.0
> > > np.sum([0.5, 0.7, 0.2, 1.5], dtype=np.int32)
> > > np.int32(1)
> > > np.sum([[0, 1], [0, 5]])
> > > 6
> > > np.sum([[0, 1], [0, 5]], axis=0)
> > > array([0, 6])
> > > np.sum([[0, 1], [0, 5]], axis=1)
> > > array([1, 5])
> > > np.sum([[0, 1], [np.nan, 5]], where=[False, True], axis=1)
> > > array([1., 5.])

If the accumulator is too small, overflow occurs:

> > > np.ones(128, dtype=np.int8).sum(dtype=np.int8)
> > > np.int8(-128)

You can also start the sum with a value other than zero:

> > > np.sum([10], initial=5)
> > > 15

---

### `numpy.where(...)`

where(condition, [x, y], /)

Return elements chosen from `x` or `y` depending on `condition`.

.. note::
When only `condition` is provided, this function is a shorthand for
``np.asarray(condition).nonzero()``. Using `nonzero` directly should be
preferred, as it behaves correctly for subclasses. The rest of this
documentation covers only the case where all three arguments are
provided.

Parameters
----------
condition : array_like, bool
Where True, yield `x`, otherwise yield `y`.
x, y : array_like
Values from which to choose. `x`, `y` and `condition` need to be
broadcastable to some shape.

Returns
-------
out : ndarray
An array with elements from `x` where `condition` is True, and elements
from `y` elsewhere.

See Also
--------
choose
nonzero : The function that is called when x and y are omitted

Notes
-----
If all the arrays are 1-D, `where` is equivalent to::

    [xv if c else yv
     for c, xv, yv in zip(condition, x, y)]

Examples
--------
> > > import numpy as np
> > > a = np.arange(10)
> > > a
> > > array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
> > > np.where(a < 5, a, 10*a)
> > > array([ 0, 1, 2, 3, 4, 50, 60, 70, 80, 90])

This can be used on multidimensional arrays too:

> > > np.where([[True, False], [True, True]],
> > > ...          [[1, 2], [3, 4]],
> > > ...          [[9, 8], [7, 6]])
> > > array([[1, 8],
[3, 4]])

The shapes of x, y, and the condition are broadcast together:

> > > x, y = np.ogrid[:3, :4]
> > > np.where(x < y, x, 10 + y)  # both x and 10+y are broadcast
> > > array([[10, 0, 0, 0],
[10, 11, 1, 1],
[10, 11, 12, 2]])

> > > a = np.array([[0, 1, 2],
> > > ...               [0, 2, 4],
> > > ...               [0, 3, 6]])
> > > np.where(a < 4, a, -1)  # -1 is broadcast
> > > array([[ 0, 1, 2],
[ 0, 2, -1],
[ 0, 3, -1]])

---

### `numpy.random.rand(*args)`

rand(d0, d1, ..., dn)

Random values in a given shape.

.. note::
This is a convenience function for users porting code from Matlab,
and wraps `random_sample`. That function takes a
tuple to specify the size of the output, which is consistent with
other NumPy functions like `numpy.zeros` and `numpy.ones`.

Create an array of the given shape and populate it with
random samples from a uniform distribution
over ``[0, 1)``.

Parameters
----------
d0, d1, ..., dn : int, optional
The dimensions of the returned array, must be non-negative.
If no argument is given a single Python float is returned.

Returns
-------
out : ndarray, shape ``(d0, d1, ..., dn)``
Random values.

See Also
--------
random

Examples
--------
> > > np.random.rand(3,2)
> > > array([[ 0.14022471, 0.96360618], #random
[ 0.37601032, 0.25528411], #random
[ 0.49313049, 0.94909878]]) #random

---
