numpy.lib.format.header_data_from_array_1_0   lib.format.header_data_from_array_1_0(array)[source]

Get the dictionary of header metadata from a numpy.ndarray.  Parameters

arraynumpy.ndarray

  Returns

ddict

This has the appropriate entries for writing its string representation to the header of the file.


numpy.lib.format.magic   lib.format.magic(major, minor)[source]

Return the magic string for the given file format version.  Parameters

majorint in [0, 255]

minorint in [0, 255]

  Returns

magicstr

  Raises
 ValueError if the version cannot be formatted.


numpy.lib.format.open_memmap   lib.format.open_memmap(filename, mode='r+', dtype=None, shape=None, fortran_order=False, version=None)[source]

Open a .npy file as a memory-mapped array. This may be used to read an existing file or create a new one.  Parameters

filenamestr or path-like

The name of the file on disk. This may not be a file-like object.
modestr, optional

The mode in which to open the file; the default is ‘r+’. In addition to the standard file modes, ‘c’ is also accepted to mean “copy on write.” See memmap for the available mode strings.
dtypedata-type, optional

The data type of the array if we are creating a new file in “write” mode, if not, dtype is ignored. The default value is None, which results in a data-type of float64.
shapetuple of int

The shape of the array if we are creating a new file in “write” mode, in which case this parameter is required. Otherwise, this parameter is ignored and is thus optional.
fortran_orderbool, optional

Whether the array should be Fortran-contiguous (True) or C-contiguous (False, the default) if we are creating a new file in “write” mode.
versiontuple of int (major, minor) or None

If the mode is a “write” mode, then this is the version of the file format used to create the file. None means use the oldest supported version that is able to store the data. Default: None    Returns

marraymemmap

The memory-mapped array.    Raises
 ValueError

If the data or the mode is invalid.  OSError

If the file is not found or cannot be opened correctly.      See also  numpy.memmap


numpy.lib.format.read_array   lib.format.read_array(fp, allow_pickle=False, pickle_kwargs=None)[source]

Read an array from an NPY file.  Parameters

fpfile_like object

If this is not a real file object, then this may take extra memory and time.
allow_picklebool, optional

Whether to allow writing pickled data. Default: False  Changed in version 1.16.3: Made default False in response to CVE-2019-6446.
pickle_kwargsdict

Additional keyword arguments to pass to pickle.load. These are only useful when loading object arrays saved on Python 2 when using Python 3.    Returns

arrayndarray

The array from the data on disk.    Raises
 ValueError

If the data is invalid, or allow_pickle=False and the file contains an object array.


numpy.lib.format.read_array_header_1_0   lib.format.read_array_header_1_0(fp)[source]

Read an array header from a filelike object using the 1.0 file format version. This will leave the file object located just after the header.  Parameters

fpfilelike object

A file object or something with a read() method like a file.    Returns

shapetuple of int

The shape of the array.
fortran_orderbool

The array data will be written out directly if it is either C-contiguous or Fortran-contiguous. Otherwise, it will be made contiguous before writing it out.
dtypedtype

The dtype of the file’s data.    Raises
 ValueError

If the data is invalid.


numpy.lib.format.read_array_header_2_0   lib.format.read_array_header_2_0(fp)[source]

Read an array header from a filelike object using the 2.0 file format version. This will leave the file object located just after the header.  New in version 1.9.0.   Parameters

fpfilelike object

A file object or something with a read() method like a file.    Returns

shapetuple of int

The shape of the array.
fortran_orderbool

The array data will be written out directly if it is either C-contiguous or Fortran-contiguous. Otherwise, it will be made contiguous before writing it out.
dtypedtype

The dtype of the file’s data.    Raises
 ValueError

If the data is invalid.


numpy.lib.format.read_magic   lib.format.read_magic(fp)[source]

Read the magic string to get the version of the file format.  Parameters

fpfilelike object

  Returns

majorint

minorint


numpy.lib.format.write_array   lib.format.write_array(fp, array, version=None, allow_pickle=True, pickle_kwargs=None)[source]

Write an array to an NPY file, including a header. If the array is neither C-contiguous nor Fortran-contiguous AND the file_like object is not a real file object, this function will have to copy data in memory.  Parameters

fpfile_like object

An open, writable file object, or similar object with a .write() method.
arrayndarray

The array to write to disk.
version(int, int) or None, optional

The version number of the format. None means use the oldest supported version that is able to store the data. Default: None
allow_picklebool, optional

Whether to allow writing pickled data. Default: True
pickle_kwargsdict, optional

Additional keyword arguments to pass to pickle.dump, excluding ‘protocol’. These are only useful when pickling objects in object arrays on Python 3 to Python 2 compatible format.    Raises
 ValueError

If the array cannot be persisted. This includes the case of allow_pickle=False and array being an object array.  Various other errors

If the array contains Python objects as part of its dtype, the process of pickling them may raise various errors if the objects are not picklable.


numpy.lib.format.write_array_header_1_0   lib.format.write_array_header_1_0(fp, d)[source]

Write the header for an array using the 1.0 format.  Parameters

fpfilelike object

ddict

This has the appropriate entries for writing its string representation to the header of the file.


numpy.lib.format.write_array_header_2_0   lib.format.write_array_header_2_0(fp, d)[source]

 Write the header for an array using the 2.0 format.

The 2.0 format allows storing very large structured arrays.    New in version 1.9.0.   Parameters

fpfilelike object

ddict

This has the appropriate entries for writing its string representation to the header of the file.


numpy.lib.scimath.arccos   lib.scimath.arccos(x)[source]

Compute the inverse cosine of x. Return the “principal value” (for a description of this, see numpy.arccos) of the inverse cosine of x. For real x such that abs(x) <= 1, this is a real number in the closed interval \([0, \pi]\). Otherwise, the complex principle value is returned.  Parameters

xarray_like or scalar

The value(s) whose arccos is (are) required.    Returns

outndarray or scalar

The inverse cosine(s) of the x value(s). If x was a scalar, so is out, otherwise an array object is returned.      See also  numpy.arccos
  Notes For an arccos() that returns NAN when real x is not in the interval [-1,1], use numpy.arccos. Examples >>> np.set_printoptions(precision=4)
 >>> np.emath.arccos(1) # a scalar is returned
0.0
 >>> np.emath.arccos([1,2])
array([0.-0.j   , 0.-1.317j])


numpy.lib.scimath.arcsin   lib.scimath.arcsin(x)[source]

Compute the inverse sine of x. Return the “principal value” (for a description of this, see numpy.arcsin) of the inverse sine of x. For real x such that abs(x) <= 1, this is a real number in the closed interval \([-\pi/2, \pi/2]\). Otherwise, the complex principle value is returned.  Parameters

xarray_like or scalar

The value(s) whose arcsin is (are) required.    Returns

outndarray or scalar

The inverse sine(s) of the x value(s). If x was a scalar, so is out, otherwise an array object is returned.      See also  numpy.arcsin
  Notes For an arcsin() that returns NAN when real x is not in the interval [-1,1], use numpy.arcsin. Examples >>> np.set_printoptions(precision=4)
 >>> np.emath.arcsin(0)
0.0
 >>> np.emath.arcsin([0,1])
array([0.    , 1.5708])


numpy.lib.scimath.arctanh   lib.scimath.arctanh(x)[source]

Compute the inverse hyperbolic tangent of x. Return the “principal value” (for a description of this, see numpy.arctanh) of arctanh(x). For real x such that abs(x) < 1, this is a real number. If abs(x) > 1, or if x is complex, the result is complex. Finally, x = 1 returns``inf`` and x=-1 returns -inf.  Parameters

xarray_like

The value(s) whose arctanh is (are) required.    Returns

outndarray or scalar

The inverse hyperbolic tangent(s) of the x value(s). If x was a scalar so is out, otherwise an array is returned.      See also  numpy.arctanh
  Notes For an arctanh() that returns NAN when real x is not in the interval (-1,1), use numpy.arctanh (this latter, however, does return +/-inf for x = +/-1). Examples >>> np.set_printoptions(precision=4)
 >>> from numpy.testing import suppress_warnings
>>> with suppress_warnings() as sup:
...     sup.filter(RuntimeWarning)
...     np.emath.arctanh(np.eye(2))
array([[inf,  0.],
       [ 0., inf]])
>>> np.emath.arctanh([1j])
array([0.+0.7854j])


numpy.lib.scimath.log   lib.scimath.log(x)[source]

Compute the natural logarithm of x. Return the “principal value” (for a description of this, see numpy.log) of \(log_e(x)\). For real x > 0, this is a real number (log(0) returns -inf and log(np.inf) returns inf). Otherwise, the complex principle value is returned.  Parameters

xarray_like

The value(s) whose log is (are) required.    Returns

outndarray or scalar

The log of the x value(s). If x was a scalar, so is out, otherwise an array is returned.      See also  numpy.log
  Notes For a log() that returns NAN when real x < 0, use numpy.log (note, however, that otherwise numpy.log and this log are identical, i.e., both return -inf for x = 0, inf for x = inf, and, notably, the complex principle value if x.imag != 0). Examples >>> np.emath.log(np.exp(1))
1.0
 Negative arguments are handled “correctly” (recall that exp(log(x)) == x does not hold for real x < 0): >>> np.emath.log(-np.exp(1)) == (1 + np.pi * 1j)
True


numpy.lib.scimath.log10   lib.scimath.log10(x)[source]

Compute the logarithm base 10 of x. Return the “principal value” (for a description of this, see numpy.log10) of \(log_{10}(x)\). For real x > 0, this is a real number (log10(0) returns -inf and log10(np.inf) returns inf). Otherwise, the complex principle value is returned.  Parameters

xarray_like or scalar

The value(s) whose log base 10 is (are) required.    Returns

outndarray or scalar

The log base 10 of the x value(s). If x was a scalar, so is out, otherwise an array object is returned.      See also  numpy.log10
  Notes For a log10() that returns NAN when real x < 0, use numpy.log10 (note, however, that otherwise numpy.log10 and this log10 are identical, i.e., both return -inf for x = 0, inf for x = inf, and, notably, the complex principle value if x.imag != 0). Examples (We set the printing precision so the example can be auto-tested) >>> np.set_printoptions(precision=4)
 >>> np.emath.log10(10**1)
1.0
 >>> np.emath.log10([-10**1, -10**2, 10**2])
array([1.+1.3644j, 2.+1.3644j, 2.+0.j    ])


numpy.lib.scimath.log2   lib.scimath.log2(x)[source]

Compute the logarithm base 2 of x. Return the “principal value” (for a description of this, see numpy.log2) of \(log_2(x)\). For real x > 0, this is a real number (log2(0) returns -inf and log2(np.inf) returns inf). Otherwise, the complex principle value is returned.  Parameters

xarray_like

The value(s) whose log base 2 is (are) required.    Returns

outndarray or scalar

The log base 2 of the x value(s). If x was a scalar, so is out, otherwise an array is returned.      See also  numpy.log2
  Notes For a log2() that returns NAN when real x < 0, use numpy.log2 (note, however, that otherwise numpy.log2 and this log2 are identical, i.e., both return -inf for x = 0, inf for x = inf, and, notably, the complex principle value if x.imag != 0). Examples We set the printing precision so the example can be auto-tested: >>> np.set_printoptions(precision=4)
 >>> np.emath.log2(8)
3.0
>>> np.emath.log2([-4, -8, 8])
array([2.+4.5324j, 3.+4.5324j, 3.+0.j    ])


numpy.lib.scimath.logn   lib.scimath.logn(n, x)[source]

Take log base n of x. If x contains negative inputs, the answer is computed and returned in the complex domain.  Parameters

narray_like

The integer base(s) in which the log is taken.
xarray_like

The value(s) whose log base n is (are) required.    Returns

outndarray or scalar

The log base n of the x value(s). If x was a scalar, so is out, otherwise an array is returned.     Examples >>> np.set_printoptions(precision=4)
 >>> np.emath.logn(2, [4, 8])
array([2., 3.])
>>> np.emath.logn(2, [-4, -8, 8])
array([2.+4.5324j, 3.+4.5324j, 3.+0.j    ])


numpy.lib.scimath.power   lib.scimath.power(x, p)[source]

Return x to the power p, (x**p). If x contains negative values, the output is converted to the complex domain.  Parameters

xarray_like

The input value(s).
parray_like of ints

The power(s) to which x is raised. If x contains multiple values, p has to either be a scalar, or contain the same number of values as x. In the latter case, the result is x[0]**p[0], x[1]**p[1], ....    Returns

outndarray or scalar

The result of x**p. If x and p are scalars, so is out, otherwise an array is returned.      See also  numpy.power
  Examples >>> np.set_printoptions(precision=4)
 >>> np.emath.power([2, 4], 2)
array([ 4, 16])
>>> np.emath.power([2, 4], -2)
array([0.25  ,  0.0625])
>>> np.emath.power([-2, 4], 2)
array([ 4.-0.j, 16.+0.j])


numpy.lib.scimath.sqrt   lib.scimath.sqrt(x)[source]

Compute the square root of x. For negative input elements, a complex value is returned (unlike numpy.sqrt which returns NaN).  Parameters

xarray_like

The input value(s).    Returns

outndarray or scalar

The square root of x. If x was a scalar, so is out, otherwise an array is returned.      See also  numpy.sqrt
  Examples For real, non-negative inputs this works just like numpy.sqrt: >>> np.emath.sqrt(1)
1.0
>>> np.emath.sqrt([1, 4])
array([1.,  2.])
 But it automatically handles negative inputs: >>> np.emath.sqrt(-1)
1j
>>> np.emath.sqrt([-1,4])
array([0.+1.j, 2.+0.j])


numpy.lib.stride_tricks.as_strided   lib.stride_tricks.as_strided(x, shape=None, strides=None, subok=False, writeable=True)[source]

Create a view into the array with the given shape and strides.  Warning This function has to be used with extreme care, see notes.   Parameters

xndarray

Array to create a new.
shapesequence of int, optional

The shape of the new array. Defaults to x.shape.
stridessequence of int, optional

The strides of the new array. Defaults to x.strides.
subokbool, optional

 New in version 1.10.  If True, subclasses are preserved.
writeablebool, optional

 New in version 1.12.  If set to False, the returned array will always be readonly. Otherwise it will be writable if the original array was. It is advisable to set this to False if possible (see Notes).    Returns

viewndarray

    See also  broadcast_to

broadcast an array to a given shape.  reshape

reshape an array.  lib.stride_tricks.sliding_window_view

userfriendly and safe function for the creation of sliding window views.    Notes as_strided creates a view into the array given the exact strides and shape. This means it manipulates the internal data structure of ndarray and, if done incorrectly, the array elements can point to invalid memory and can corrupt results or crash your program. It is advisable to always use the original x.strides when calculating new strides to avoid reliance on a contiguous memory layout. Furthermore, arrays created with this function often contain self overlapping memory, so that two elements are identical. Vectorized write operations on such arrays will typically be unpredictable. They may even give different results for small, large, or transposed arrays. Since writing to these arrays has to be tested and done with great care, you may want to use writeable=False to avoid accidental write operations. For these reasons it is advisable to avoid as_strided when possible.


numpy.lib.stride_tricks.sliding_window_view   lib.stride_tricks.sliding_window_view(x, window_shape, axis=None, *, subok=False, writeable=False)[source]

Create a sliding window view into the array with the given window shape. Also known as rolling or moving window, the window slides across all dimensions of the array and extracts subsets of the array at all window positions.  New in version 1.20.0.   Parameters

xarray_like

Array to create the sliding window view from.
window_shapeint or tuple of int

Size of window over each axis that takes part in the sliding window. If axis is not present, must have same length as the number of input array dimensions. Single integers i are treated as if they were the tuple (i,).
axisint or tuple of int, optional

Axis or axes along which the sliding window is applied. By default, the sliding window is applied to all axes and window_shape[i] will refer to axis i of x. If axis is given as a tuple of int, window_shape[i] will refer to the axis axis[i] of x. Single integers i are treated as if they were the tuple (i,).
subokbool, optional

If True, sub-classes will be passed-through, otherwise the returned array will be forced to be a base-class array (default).
writeablebool, optional

When true, allow writing to the returned view. The default is false, as this should be used with caution: the returned view contains the same memory location multiple times, so writing to one location will cause others to change.    Returns

viewndarray

Sliding window view of the array. The sliding window dimensions are inserted at the end, and the original dimensions are trimmed as required by the size of the sliding window. That is, view.shape = x_shape_trimmed + window_shape, where x_shape_trimmed is x.shape with every entry reduced by one less than the corresponding window size.      See also  lib.stride_tricks.as_strided

A lower-level and less safe routine for creating arbitrary views from custom shape and strides.  broadcast_to

broadcast an array to a given shape.    Notes For many applications using a sliding window view can be convenient, but potentially very slow. Often specialized solutions exist, for example:  scipy.signal.fftconvolve filtering functions in scipy.ndimage
 moving window functions provided by bottleneck.  As a rough estimate, a sliding window approach with an input size of N and a window size of W will scale as O(N*W) where frequently a special algorithm can achieve O(N). That means that the sliding window variant for a window size of 100 can be a 100 times slower than a more specialized version. Nevertheless, for small window sizes, when no custom algorithm exists, or as a prototyping and developing tool, this function can be a good solution. Examples >>> x = np.arange(6)
>>> x.shape
(6,)
>>> v = sliding_window_view(x, 3)
>>> v.shape
(4, 3)
>>> v
array([[0, 1, 2],
       [1, 2, 3],
       [2, 3, 4],
       [3, 4, 5]])
 This also works in more dimensions, e.g. >>> i, j = np.ogrid[:3, :4]
>>> x = 10*i + j
>>> x.shape
(3, 4)
>>> x
array([[ 0,  1,  2,  3],
       [10, 11, 12, 13],
       [20, 21, 22, 23]])
>>> shape = (2,2)
>>> v = sliding_window_view(x, shape)
>>> v.shape
(2, 3, 2, 2)
>>> v
array([[[[ 0,  1],
         [10, 11]],
        [[ 1,  2],
         [11, 12]],
        [[ 2,  3],
         [12, 13]]],
       [[[10, 11],
         [20, 21]],
        [[11, 12],
         [21, 22]],
        [[12, 13],
         [22, 23]]]])
 The axis can be specified explicitly: >>> v = sliding_window_view(x, 3, 0)
>>> v.shape
(1, 4, 3)
>>> v
array([[[ 0, 10, 20],
        [ 1, 11, 21],
        [ 2, 12, 22],
        [ 3, 13, 23]]])
 The same axis can be used several times. In that case, every use reduces the corresponding original dimension: >>> v = sliding_window_view(x, (2, 3), (1, 1))
>>> v.shape
(3, 1, 2, 3)
>>> v
array([[[[ 0,  1,  2],
         [ 1,  2,  3]]],
       [[[10, 11, 12],
         [11, 12, 13]]],
       [[[20, 21, 22],
         [21, 22, 23]]]])
 Combining with stepped slicing (::step), this can be used to take sliding views which skip elements: >>> x = np.arange(7)
>>> sliding_window_view(x, 5)[:, ::2]
array([[0, 2, 4],
       [1, 3, 5],
       [2, 4, 6]])
 or views which move by multiple elements >>> x = np.arange(7)
>>> sliding_window_view(x, 3)[::2, :]
array([[0, 1, 2],
       [2, 3, 4],
       [4, 5, 6]])
 A common application of sliding_window_view is the calculation of running statistics. The simplest example is the moving average: >>> x = np.arange(6)
>>> x.shape
(6,)
>>> v = sliding_window_view(x, 3)
>>> v.shape
(4, 3)
>>> v
array([[0, 1, 2],
       [1, 2, 3],
       [2, 3, 4],
       [3, 4, 5]])
>>> moving_average = v.mean(axis=-1)
>>> moving_average
array([1., 2., 3., 4.])
 Note that a sliding window approach is often not optimal (see Notes).


numpy.linalg.cholesky   linalg.cholesky(a)[source]

Cholesky decomposition. Return the Cholesky decomposition, L * L.H, of the square matrix a, where L is lower-triangular and .H is the conjugate transpose operator (which is the ordinary transpose if a is real-valued). a must be Hermitian (symmetric if real-valued) and positive-definite. No checking is performed to verify whether a is Hermitian or not. In addition, only the lower-triangular and diagonal elements of a are used. Only L is actually returned.  Parameters

a(…, M, M) array_like

Hermitian (symmetric if all elements are real), positive-definite input matrix.    Returns

L(…, M, M) array_like

Upper or lower-triangular Cholesky factor of a. Returns a matrix object if a is a matrix object.    Raises
 LinAlgError

If the decomposition fails, for example, if a is not positive-definite.      See also  scipy.linalg.cholesky

Similar function in SciPy.  scipy.linalg.cholesky_banded

Cholesky decompose a banded Hermitian positive-definite matrix.  scipy.linalg.cho_factor

Cholesky decomposition of a matrix, to use in scipy.linalg.cho_solve.    Notes  New in version 1.8.0.  Broadcasting rules apply, see the numpy.linalg documentation for details. The Cholesky decomposition is often used as a fast way of solving  \[A \mathbf{x} = \mathbf{b}\] (when A is both Hermitian/symmetric and positive-definite). First, we solve for \(\mathbf{y}\) in  \[L \mathbf{y} = \mathbf{b},\] and then for \(\mathbf{x}\) in  \[L.H \mathbf{x} = \mathbf{y}.\] Examples >>> A = np.array([[1,-2j],[2j,5]])
>>> A
array([[ 1.+0.j, -0.-2.j],
       [ 0.+2.j,  5.+0.j]])
>>> L = np.linalg.cholesky(A)
>>> L
array([[1.+0.j, 0.+0.j],
       [0.+2.j, 1.+0.j]])
>>> np.dot(L, L.T.conj()) # verify that L * L.H = A
array([[1.+0.j, 0.-2.j],
       [0.+2.j, 5.+0.j]])
>>> A = [[1,-2j],[2j,5]] # what happens if A is only array_like?
>>> np.linalg.cholesky(A) # an ndarray object is returned
array([[1.+0.j, 0.+0.j],
       [0.+2.j, 1.+0.j]])
>>> # But a matrix object is returned if A is a matrix object
>>> np.linalg.cholesky(np.matrix(A))
matrix([[ 1.+0.j,  0.+0.j],
        [ 0.+2.j,  1.+0.j]])


numpy.linalg.cond   linalg.cond(x, p=None)[source]

Compute the condition number of a matrix. This function is capable of returning the condition number using one of seven different norms, depending on the value of p (see Parameters below).  Parameters

x(…, M, N) array_like

The matrix whose condition number is sought.
p{None, 1, -1, 2, -2, inf, -inf, ‘fro’}, optional

Order of the norm used in the condition number computation:
p norm for matrices
None 2-norm, computed directly using the SVD
‘fro’ Frobenius norm
inf max(sum(abs(x), axis=1))
-inf min(sum(abs(x), axis=1))
1 max(sum(abs(x), axis=0))
-1 min(sum(abs(x), axis=0))
2 2-norm (largest sing. value)
-2 smallest singular value   inf means the numpy.inf object, and the Frobenius norm is the root-of-sum-of-squares norm.    Returns

c{float, inf}

The condition number of the matrix. May be infinite.      See also  numpy.linalg.norm
  Notes The condition number of x is defined as the norm of x times the norm of the inverse of x [1]; the norm can be the usual L2-norm (root-of-sum-of-squares) or one of a number of other matrix norms. References  1
G. Strang, Linear Algebra and Its Applications, Orlando, FL, Academic Press, Inc., 1980, pg. 285.   Examples >>> from numpy import linalg as LA
>>> a = np.array([[1, 0, -1], [0, 1, 0], [1, 0, 1]])
>>> a
array([[ 1,  0, -1],
       [ 0,  1,  0],
       [ 1,  0,  1]])
>>> LA.cond(a)
1.4142135623730951
>>> LA.cond(a, 'fro')
3.1622776601683795
>>> LA.cond(a, np.inf)
2.0
>>> LA.cond(a, -np.inf)
1.0
>>> LA.cond(a, 1)
2.0
>>> LA.cond(a, -1)
1.0
>>> LA.cond(a, 2)
1.4142135623730951
>>> LA.cond(a, -2)
0.70710678118654746 # may vary
>>> min(LA.svd(a, compute_uv=False))*min(LA.svd(LA.inv(a), compute_uv=False))
0.70710678118654746 # may vary


numpy.linalg.det   linalg.det(a)[source]

Compute the determinant of an array.  Parameters

a(…, M, M) array_like

Input array to compute determinants for.    Returns

det(…) array_like

Determinant of a.      See also  slogdet

Another way to represent the determinant, more suitable for large matrices where underflow/overflow may occur.  scipy.linalg.det

Similar function in SciPy.    Notes  New in version 1.8.0.  Broadcasting rules apply, see the numpy.linalg documentation for details. The determinant is computed via LU factorization using the LAPACK routine z/dgetrf. Examples The determinant of a 2-D array [[a, b], [c, d]] is ad - bc: >>> a = np.array([[1, 2], [3, 4]])
>>> np.linalg.det(a)
-2.0 # may vary
 Computing determinants for a stack of matrices: >>> a = np.array([ [[1, 2], [3, 4]], [[1, 2], [2, 1]], [[1, 3], [3, 1]] ])
>>> a.shape
(3, 2, 2)
>>> np.linalg.det(a)
array([-2., -3., -8.])


numpy.linalg.eig   linalg.eig(a)[source]

Compute the eigenvalues and right eigenvectors of a square array.  Parameters

a(…, M, M) array

Matrices for which the eigenvalues and right eigenvectors will be computed    Returns

w(…, M) array

The eigenvalues, each repeated according to its multiplicity. The eigenvalues are not necessarily ordered. The resulting array will be of complex type, unless the imaginary part is zero in which case it will be cast to a real type. When a is real the resulting eigenvalues will be real (0 imaginary part) or occur in conjugate pairs
v(…, M, M) array

The normalized (unit “length”) eigenvectors, such that the column v[:,i] is the eigenvector corresponding to the eigenvalue w[i].    Raises
 LinAlgError

If the eigenvalue computation does not converge.      See also  eigvals

eigenvalues of a non-symmetric array.  eigh

eigenvalues and eigenvectors of a real symmetric or complex Hermitian (conjugate symmetric) array.  eigvalsh

eigenvalues of a real symmetric or complex Hermitian (conjugate symmetric) array.  scipy.linalg.eig

Similar function in SciPy that also solves the generalized eigenvalue problem.  scipy.linalg.schur

Best choice for unitary and other non-Hermitian normal matrices.    Notes  New in version 1.8.0.  Broadcasting rules apply, see the numpy.linalg documentation for details. This is implemented using the _geev LAPACK routines which compute the eigenvalues and eigenvectors of general square arrays. The number w is an eigenvalue of a if there exists a vector v such that a @ v = w * v. Thus, the arrays a, w, and v satisfy the equations a @ v[:,i] = w[i] * v[:,i] for \(i \in \{0,...,M-1\}\). The array v of eigenvectors may not be of maximum rank, that is, some of the columns may be linearly dependent, although round-off error may obscure that fact. If the eigenvalues are all different, then theoretically the eigenvectors are linearly independent and a can be diagonalized by a similarity transformation using v, i.e, inv(v) @ a @ v is diagonal. For non-Hermitian normal matrices the SciPy function scipy.linalg.schur is preferred because the matrix v is guaranteed to be unitary, which is not the case when using eig. The Schur factorization produces an upper triangular matrix rather than a diagonal matrix, but for normal matrices only the diagonal of the upper triangular matrix is needed, the rest is roundoff error. Finally, it is emphasized that v consists of the right (as in right-hand side) eigenvectors of a. A vector y satisfying y.T @ a = z * y.T for some number z is called a left eigenvector of a, and, in general, the left and right eigenvectors of a matrix are not necessarily the (perhaps conjugate) transposes of each other. References G. Strang, Linear Algebra and Its Applications, 2nd Ed., Orlando, FL, Academic Press, Inc., 1980, Various pp. Examples >>> from numpy import linalg as LA
 (Almost) trivial example with real e-values and e-vectors. >>> w, v = LA.eig(np.diag((1, 2, 3)))
>>> w; v
array([1., 2., 3.])
array([[1., 0., 0.],
       [0., 1., 0.],
       [0., 0., 1.]])
 Real matrix possessing complex e-values and e-vectors; note that the e-values are complex conjugates of each other. >>> w, v = LA.eig(np.array([[1, -1], [1, 1]]))
>>> w; v
array([1.+1.j, 1.-1.j])
array([[0.70710678+0.j        , 0.70710678-0.j        ],
       [0.        -0.70710678j, 0.        +0.70710678j]])
 Complex-valued matrix with real e-values (but complex-valued e-vectors); note that a.conj().T == a, i.e., a is Hermitian. >>> a = np.array([[1, 1j], [-1j, 1]])
>>> w, v = LA.eig(a)
>>> w; v
array([2.+0.j, 0.+0.j])
array([[ 0.        +0.70710678j,  0.70710678+0.j        ], # may vary
       [ 0.70710678+0.j        , -0.        +0.70710678j]])
 Be careful about round-off error! >>> a = np.array([[1 + 1e-9, 0], [0, 1 - 1e-9]])
>>> # Theor. e-values are 1 +/- 1e-9
>>> w, v = LA.eig(a)
>>> w; v
array([1., 1.])
array([[1., 0.],
       [0., 1.]])


numpy.linalg.eigh   linalg.eigh(a, UPLO='L')[source]

Return the eigenvalues and eigenvectors of a complex Hermitian (conjugate symmetric) or a real symmetric matrix. Returns two objects, a 1-D array containing the eigenvalues of a, and a 2-D square array or matrix (depending on the input type) of the corresponding eigenvectors (in columns).  Parameters

a(…, M, M) array

Hermitian or real symmetric matrices whose eigenvalues and eigenvectors are to be computed.
UPLO{‘L’, ‘U’}, optional

Specifies whether the calculation is done with the lower triangular part of a (‘L’, default) or the upper triangular part (‘U’). Irrespective of this value only the real parts of the diagonal will be considered in the computation to preserve the notion of a Hermitian matrix. It therefore follows that the imaginary part of the diagonal will always be treated as zero.    Returns

w(…, M) ndarray

The eigenvalues in ascending order, each repeated according to its multiplicity.
v{(…, M, M) ndarray, (…, M, M) matrix}

The column v[:, i] is the normalized eigenvector corresponding to the eigenvalue w[i]. Will return a matrix object if a is a matrix object.    Raises
 LinAlgError

If the eigenvalue computation does not converge.      See also  eigvalsh

eigenvalues of real symmetric or complex Hermitian (conjugate symmetric) arrays.  eig

eigenvalues and right eigenvectors for non-symmetric arrays.  eigvals

eigenvalues of non-symmetric arrays.  scipy.linalg.eigh

Similar function in SciPy (but also solves the generalized eigenvalue problem).    Notes  New in version 1.8.0.  Broadcasting rules apply, see the numpy.linalg documentation for details. The eigenvalues/eigenvectors are computed using LAPACK routines _syevd, _heevd. The eigenvalues of real symmetric or complex Hermitian matrices are always real. [1] The array v of (column) eigenvectors is unitary and a, w, and v satisfy the equations dot(a, v[:, i]) = w[i] * v[:, i]. References  1
G. Strang, Linear Algebra and Its Applications, 2nd Ed., Orlando, FL, Academic Press, Inc., 1980, pg. 222.   Examples >>> from numpy import linalg as LA
>>> a = np.array([[1, -2j], [2j, 5]])
>>> a
array([[ 1.+0.j, -0.-2.j],
       [ 0.+2.j,  5.+0.j]])
>>> w, v = LA.eigh(a)
>>> w; v
array([0.17157288, 5.82842712])
array([[-0.92387953+0.j        , -0.38268343+0.j        ], # may vary
       [ 0.        +0.38268343j,  0.        -0.92387953j]])
 >>> np.dot(a, v[:, 0]) - w[0] * v[:, 0] # verify 1st e-val/vec pair
array([5.55111512e-17+0.0000000e+00j, 0.00000000e+00+1.2490009e-16j])
>>> np.dot(a, v[:, 1]) - w[1] * v[:, 1] # verify 2nd e-val/vec pair
array([0.+0.j, 0.+0.j])
 >>> A = np.matrix(a) # what happens if input is a matrix object
>>> A
matrix([[ 1.+0.j, -0.-2.j],
        [ 0.+2.j,  5.+0.j]])
>>> w, v = LA.eigh(A)
>>> w; v
array([0.17157288, 5.82842712])
matrix([[-0.92387953+0.j        , -0.38268343+0.j        ], # may vary
        [ 0.        +0.38268343j,  0.        -0.92387953j]])
 >>> # demonstrate the treatment of the imaginary part of the diagonal
>>> a = np.array([[5+2j, 9-2j], [0+2j, 2-1j]])
>>> a
array([[5.+2.j, 9.-2.j],
       [0.+2.j, 2.-1.j]])
>>> # with UPLO='L' this is numerically equivalent to using LA.eig() with:
>>> b = np.array([[5.+0.j, 0.-2.j], [0.+2.j, 2.-0.j]])
>>> b
array([[5.+0.j, 0.-2.j],
       [0.+2.j, 2.+0.j]])
>>> wa, va = LA.eigh(a)
>>> wb, vb = LA.eig(b)
>>> wa; wb
array([1., 6.])
array([6.+0.j, 1.+0.j])
>>> va; vb
array([[-0.4472136 +0.j        , -0.89442719+0.j        ], # may vary
       [ 0.        +0.89442719j,  0.        -0.4472136j ]])
array([[ 0.89442719+0.j       , -0.        +0.4472136j],
       [-0.        +0.4472136j,  0.89442719+0.j       ]])


numpy.linalg.eigvals   linalg.eigvals(a)[source]

Compute the eigenvalues of a general matrix. Main difference between eigvals and eig: the eigenvectors aren’t returned.  Parameters

a(…, M, M) array_like

A complex- or real-valued matrix whose eigenvalues will be computed.    Returns

w(…, M,) ndarray

The eigenvalues, each repeated according to its multiplicity. They are not necessarily ordered, nor are they necessarily real for real matrices.    Raises
 LinAlgError

If the eigenvalue computation does not converge.      See also  eig

eigenvalues and right eigenvectors of general arrays  eigvalsh

eigenvalues of real symmetric or complex Hermitian (conjugate symmetric) arrays.  eigh

eigenvalues and eigenvectors of real symmetric or complex Hermitian (conjugate symmetric) arrays.  scipy.linalg.eigvals

Similar function in SciPy.    Notes  New in version 1.8.0.  Broadcasting rules apply, see the numpy.linalg documentation for details. This is implemented using the _geev LAPACK routines which compute the eigenvalues and eigenvectors of general square arrays. Examples Illustration, using the fact that the eigenvalues of a diagonal matrix are its diagonal elements, that multiplying a matrix on the left by an orthogonal matrix, Q, and on the right by Q.T (the transpose of Q), preserves the eigenvalues of the “middle” matrix. In other words, if Q is orthogonal, then Q * A * Q.T has the same eigenvalues as A: >>> from numpy import linalg as LA
>>> x = np.random.random()
>>> Q = np.array([[np.cos(x), -np.sin(x)], [np.sin(x), np.cos(x)]])
>>> LA.norm(Q[0, :]), LA.norm(Q[1, :]), np.dot(Q[0, :],Q[1, :])
(1.0, 1.0, 0.0)
 Now multiply a diagonal matrix by Q on one side and by Q.T on the other: >>> D = np.diag((-1,1))
>>> LA.eigvals(D)
array([-1.,  1.])
>>> A = np.dot(Q, D)
>>> A = np.dot(A, Q.T)
>>> LA.eigvals(A)
array([ 1., -1.]) # random


numpy.linalg.eigvalsh   linalg.eigvalsh(a, UPLO='L')[source]

Compute the eigenvalues of a complex Hermitian or real symmetric matrix. Main difference from eigh: the eigenvectors are not computed.  Parameters

a(…, M, M) array_like

A complex- or real-valued matrix whose eigenvalues are to be computed.
UPLO{‘L’, ‘U’}, optional

Specifies whether the calculation is done with the lower triangular part of a (‘L’, default) or the upper triangular part (‘U’). Irrespective of this value only the real parts of the diagonal will be considered in the computation to preserve the notion of a Hermitian matrix. It therefore follows that the imaginary part of the diagonal will always be treated as zero.    Returns

w(…, M,) ndarray

The eigenvalues in ascending order, each repeated according to its multiplicity.    Raises
 LinAlgError

If the eigenvalue computation does not converge.      See also  eigh

eigenvalues and eigenvectors of real symmetric or complex Hermitian (conjugate symmetric) arrays.  eigvals

eigenvalues of general real or complex arrays.  eig

eigenvalues and right eigenvectors of general real or complex arrays.  scipy.linalg.eigvalsh

Similar function in SciPy.    Notes  New in version 1.8.0.  Broadcasting rules apply, see the numpy.linalg documentation for details. The eigenvalues are computed using LAPACK routines _syevd, _heevd. Examples >>> from numpy import linalg as LA
>>> a = np.array([[1, -2j], [2j, 5]])
>>> LA.eigvalsh(a)
array([ 0.17157288,  5.82842712]) # may vary
 >>> # demonstrate the treatment of the imaginary part of the diagonal
>>> a = np.array([[5+2j, 9-2j], [0+2j, 2-1j]])
>>> a
array([[5.+2.j, 9.-2.j],
       [0.+2.j, 2.-1.j]])
>>> # with UPLO='L' this is numerically equivalent to using LA.eigvals()
>>> # with:
>>> b = np.array([[5.+0.j, 0.-2.j], [0.+2.j, 2.-0.j]])
>>> b
array([[5.+0.j, 0.-2.j],
       [0.+2.j, 2.+0.j]])
>>> wa = LA.eigvalsh(a)
>>> wb = LA.eigvals(b)
>>> wa; wb
array([1., 6.])
array([6.+0.j, 1.+0.j])


numpy.linalg.inv   linalg.inv(a)[source]

Compute the (multiplicative) inverse of a matrix. Given a square matrix a, return the matrix ainv satisfying dot(a, ainv) = dot(ainv, a) = eye(a.shape[0]).  Parameters

a(…, M, M) array_like

Matrix to be inverted.    Returns

ainv(…, M, M) ndarray or matrix

(Multiplicative) inverse of the matrix a.    Raises
 LinAlgError

If a is not square or inversion fails.      See also  scipy.linalg.inv

Similar function in SciPy.    Notes  New in version 1.8.0.  Broadcasting rules apply, see the numpy.linalg documentation for details. Examples >>> from numpy.linalg import inv
>>> a = np.array([[1., 2.], [3., 4.]])
>>> ainv = inv(a)
>>> np.allclose(np.dot(a, ainv), np.eye(2))
True
>>> np.allclose(np.dot(ainv, a), np.eye(2))
True
 If a is a matrix object, then the return value is a matrix as well: >>> ainv = inv(np.matrix(a))
>>> ainv
matrix([[-2. ,  1. ],
        [ 1.5, -0.5]])
 Inverses of several matrices can be computed at once: >>> a = np.array([[[1., 2.], [3., 4.]], [[1, 3], [3, 5]]])
>>> inv(a)
array([[[-2.  ,  1.  ],
        [ 1.5 , -0.5 ]],
       [[-1.25,  0.75],
        [ 0.75, -0.25]]])


numpy.linalg.LinAlgError   exception linalg.LinAlgError[source]

Generic Python-exception-derived object raised by linalg functions. General purpose exception class, derived from Python’s exception.Exception class, programmatically raised in linalg functions when a Linear Algebra-related condition would prevent further correct execution of the function.  Parameters
 None
   Examples >>> from numpy import linalg as LA
>>> LA.inv(np.zeros((2,2)))
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "...linalg.py", line 350,
    in inv return wrap(solve(a, identity(a.shape[0], dtype=a.dtype)))
  File "...linalg.py", line 249,
    in solve
    raise LinAlgError('Singular matrix')
numpy.linalg.LinAlgError: Singular matrix


numpy.linalg.lstsq   linalg.lstsq(a, b, rcond='warn')[source]

Return the least-squares solution to a linear matrix equation. Computes the vector x that approximately solves the equation a @ x = b. The equation may be under-, well-, or over-determined (i.e., the number of linearly independent rows of a can be less than, equal to, or greater than its number of linearly independent columns). If a is square and of full rank, then x (but for round-off error) is the “exact” solution of the equation. Else, x minimizes the Euclidean 2-norm \(||b - ax||\). If there are multiple minimizing solutions, the one with the smallest 2-norm \(||x||\) is returned.  Parameters

a(M, N) array_like

“Coefficient” matrix.
b{(M,), (M, K)} array_like

Ordinate or “dependent variable” values. If b is two-dimensional, the least-squares solution is calculated for each of the K columns of b.
rcondfloat, optional

Cut-off ratio for small singular values of a. For the purposes of rank determination, singular values are treated as zero if they are smaller than rcond times the largest singular value of a.  Changed in version 1.14.0: If not set, a FutureWarning is given. The previous default of -1 will use the machine precision as rcond parameter, the new default will use the machine precision times max(M, N). To silence the warning and use the new default, use rcond=None, to keep using the old behavior, use rcond=-1.     Returns

x{(N,), (N, K)} ndarray

Least-squares solution. If b is two-dimensional, the solutions are in the K columns of x.
residuals{(1,), (K,), (0,)} ndarray

Sums of squared residuals: Squared Euclidean 2-norm for each column in b - a @ x. If the rank of a is < N or M <= N, this is an empty array. If b is 1-dimensional, this is a (1,) shape array. Otherwise the shape is (K,).
rankint

Rank of matrix a.
s(min(M, N),) ndarray

Singular values of a.    Raises
 LinAlgError

If computation does not converge.      See also  scipy.linalg.lstsq

Similar function in SciPy.    Notes If b is a matrix, then all array results are returned as matrices. Examples Fit a line, y = mx + c, through some noisy data-points: >>> x = np.array([0, 1, 2, 3])
>>> y = np.array([-1, 0.2, 0.9, 2.1])
 By examining the coefficients, we see that the line should have a gradient of roughly 1 and cut the y-axis at, more or less, -1. We can rewrite the line equation as y = Ap, where A = [[x 1]] and p = [[m], [c]]. Now use lstsq to solve for p: >>> A = np.vstack([x, np.ones(len(x))]).T
>>> A
array([[ 0.,  1.],
       [ 1.,  1.],
       [ 2.,  1.],
       [ 3.,  1.]])
 >>> m, c = np.linalg.lstsq(A, y, rcond=None)[0]
>>> m, c
(1.0 -0.95) # may vary
 Plot the data along with the fitted line: >>> import matplotlib.pyplot as plt
>>> _ = plt.plot(x, y, 'o', label='Original data', markersize=10)
>>> _ = plt.plot(x, m*x + c, 'r', label='Fitted line')
>>> _ = plt.legend()
>>> plt.show()


numpy.linalg.matrix_power   linalg.matrix_power(a, n)[source]

Raise a square matrix to the (integer) power n. For positive integers n, the power is computed by repeated matrix squarings and matrix multiplications. If n == 0, the identity matrix of the same shape as M is returned. If n < 0, the inverse is computed and then raised to the abs(n).  Note Stacks of object matrices are not currently supported.   Parameters

a(…, M, M) array_like

Matrix to be “powered”.
nint

The exponent can be any integer or long integer, positive, negative, or zero.    Returns

a**n(…, M, M) ndarray or matrix object

The return value is the same shape and type as M; if the exponent is positive or zero then the type of the elements is the same as those of M. If the exponent is negative the elements are floating-point.    Raises
 LinAlgError

For matrices that are not square or that (for negative powers) cannot be inverted numerically.     Examples >>> from numpy.linalg import matrix_power
>>> i = np.array([[0, 1], [-1, 0]]) # matrix equiv. of the imaginary unit
>>> matrix_power(i, 3) # should = -i
array([[ 0, -1],
       [ 1,  0]])
>>> matrix_power(i, 0)
array([[1, 0],
       [0, 1]])
>>> matrix_power(i, -3) # should = 1/(-i) = i, but w/ f.p. elements
array([[ 0.,  1.],
       [-1.,  0.]])
 Somewhat more sophisticated example >>> q = np.zeros((4, 4))
>>> q[0:2, 0:2] = -i
>>> q[2:4, 2:4] = i
>>> q # one of the three quaternion units not equal to 1
array([[ 0., -1.,  0.,  0.],
       [ 1.,  0.,  0.,  0.],
       [ 0.,  0.,  0.,  1.],
       [ 0.,  0., -1.,  0.]])
>>> matrix_power(q, 2) # = -np.eye(4)
array([[-1.,  0.,  0.,  0.],
       [ 0., -1.,  0.,  0.],
       [ 0.,  0., -1.,  0.],
       [ 0.,  0.,  0., -1.]])


numpy.linalg.matrix_rank   linalg.matrix_rank(A, tol=None, hermitian=False)[source]

Return matrix rank of array using SVD method Rank of the array is the number of singular values of the array that are greater than tol.  Changed in version 1.14: Can now operate on stacks of matrices   Parameters

A{(M,), (…, M, N)} array_like

Input vector or stack of matrices.
tol(…) array_like, float, optional

Threshold below which SVD values are considered zero. If tol is None, and S is an array with singular values for M, and eps is the epsilon value for datatype of S, then tol is set to S.max() * max(M, N) * eps.  Changed in version 1.14: Broadcasted against the stack of matrices
hermitianbool, optional

If True, A is assumed to be Hermitian (symmetric if real-valued), enabling a more efficient method for finding singular values. Defaults to False.  New in version 1.14.     Returns

rank(…) array_like

Rank of A.     Notes The default threshold to detect rank deficiency is a test on the magnitude of the singular values of A. By default, we identify singular values less than S.max() * max(M, N) * eps as indicating rank deficiency (with the symbols defined above). This is the algorithm MATLAB uses [1]. It also appears in Numerical recipes in the discussion of SVD solutions for linear least squares [2]. This default threshold is designed to detect rank deficiency accounting for the numerical errors of the SVD computation. Imagine that there is a column in A that is an exact (in floating point) linear combination of other columns in A. Computing the SVD on A will not produce a singular value exactly equal to 0 in general: any difference of the smallest SVD value from 0 will be caused by numerical imprecision in the calculation of the SVD. Our threshold for small SVD values takes this numerical imprecision into account, and the default threshold will detect such numerical rank deficiency. The threshold may declare a matrix A rank deficient even if the linear combination of some columns of A is not exactly equal to another column of A but only numerically very close to another column of A. We chose our default threshold because it is in wide use. Other thresholds are possible. For example, elsewhere in the 2007 edition of Numerical recipes there is an alternative threshold of S.max() *
np.finfo(A.dtype).eps / 2. * np.sqrt(m + n + 1.). The authors describe this threshold as being based on “expected roundoff error” (p 71). The thresholds above deal with floating point roundoff error in the calculation of the SVD. However, you may have more information about the sources of error in A that would make you consider other tolerance values to detect effective rank deficiency. The most useful measure of the tolerance depends on the operations you intend to use on your matrix. For example, if your data come from uncertain measurements with uncertainties greater than floating point epsilon, choosing a tolerance near that uncertainty may be preferable. The tolerance may be absolute if the uncertainties are absolute rather than relative. References  1
MATLAB reference documentation, “Rank” https://www.mathworks.com/help/techdoc/ref/rank.html  2
W. H. Press, S. A. Teukolsky, W. T. Vetterling and B. P. Flannery, “Numerical Recipes (3rd edition)”, Cambridge University Press, 2007, page 795.   Examples >>> from numpy.linalg import matrix_rank
>>> matrix_rank(np.eye(4)) # Full rank matrix
4
>>> I=np.eye(4); I[-1,-1] = 0. # rank deficient matrix
>>> matrix_rank(I)
3
>>> matrix_rank(np.ones((4,))) # 1 dimension - rank 1 unless all 0
1
>>> matrix_rank(np.zeros((4,)))
0


numpy.linalg.multi_dot   linalg.multi_dot(arrays, *, out=None)[source]

Compute the dot product of two or more arrays in a single function call, while automatically selecting the fastest evaluation order. multi_dot chains numpy.dot and uses optimal parenthesization of the matrices [1] [2]. Depending on the shapes of the matrices, this can speed up the multiplication a lot. If the first argument is 1-D it is treated as a row vector. If the last argument is 1-D it is treated as a column vector. The other arguments must be 2-D. Think of multi_dot as: def multi_dot(arrays): return functools.reduce(np.dot, arrays)
  Parameters

arrayssequence of array_like

If the first argument is 1-D it is treated as row vector. If the last argument is 1-D it is treated as column vector. The other arguments must be 2-D.
outndarray, optional

Output argument. This must have the exact kind that would be returned if it was not used. In particular, it must have the right type, must be C-contiguous, and its dtype must be the dtype that would be returned for dot(a, b). This is a performance feature. Therefore, if these conditions are not met, an exception is raised, instead of attempting to be flexible.  New in version 1.19.0.     Returns

outputndarray

Returns the dot product of the supplied arrays.      See also  numpy.dot

dot multiplication with two arguments.    Notes The cost for a matrix multiplication can be calculated with the following function: def cost(A, B):
    return A.shape[0] * A.shape[1] * B.shape[1]
 Assume we have three matrices \(A_{10x100}, B_{100x5}, C_{5x50}\). The costs for the two different parenthesizations are as follows: cost((AB)C) = 10*100*5 + 10*5*50   = 5000 + 2500   = 7500
cost(A(BC)) = 10*100*50 + 100*5*50 = 50000 + 25000 = 75000
 References  1
Cormen, “Introduction to Algorithms”, Chapter 15.2, p. 370-378  2
https://en.wikipedia.org/wiki/Matrix_chain_multiplication   Examples multi_dot allows you to write: >>> from numpy.linalg import multi_dot
>>> # Prepare some data
>>> A = np.random.random((10000, 100))
>>> B = np.random.random((100, 1000))
>>> C = np.random.random((1000, 5))
>>> D = np.random.random((5, 333))
>>> # the actual dot multiplication
>>> _ = multi_dot([A, B, C, D])
 instead of: >>> _ = np.dot(np.dot(np.dot(A, B), C), D)
>>> # or
>>> _ = A.dot(B).dot(C).dot(D)


numpy.linalg.norm   linalg.norm(x, ord=None, axis=None, keepdims=False)[source]

Matrix or vector norm. This function is able to return one of eight different matrix norms, or one of an infinite number of vector norms (described below), depending on the value of the ord parameter.  Parameters

xarray_like

Input array. If axis is None, x must be 1-D or 2-D, unless ord is None. If both axis and ord are None, the 2-norm of x.ravel will be returned.
ord{non-zero int, inf, -inf, ‘fro’, ‘nuc’}, optional

Order of the norm (see table under Notes). inf means numpy’s inf object. The default is None.
axis{None, int, 2-tuple of ints}, optional.

If axis is an integer, it specifies the axis of x along which to compute the vector norms. If axis is a 2-tuple, it specifies the axes that hold 2-D matrices, and the matrix norms of these matrices are computed. If axis is None then either a vector norm (when x is 1-D) or a matrix norm (when x is 2-D) is returned. The default is None.  New in version 1.8.0.
keepdimsbool, optional

If this is set to True, the axes which are normed over are left in the result as dimensions with size one. With this option the result will broadcast correctly against the original x.  New in version 1.10.0.     Returns

nfloat or ndarray

Norm of the matrix or vector(s).      See also  scipy.linalg.norm

Similar function in SciPy.    Notes For values of ord < 1, the result is, strictly speaking, not a mathematical ‘norm’, but it may still be useful for various numerical purposes. The following norms can be calculated:
ord norm for matrices norm for vectors
None Frobenius norm 2-norm
‘fro’ Frobenius norm –
‘nuc’ nuclear norm –
inf max(sum(abs(x), axis=1)) max(abs(x))
-inf min(sum(abs(x), axis=1)) min(abs(x))
0 – sum(x != 0)
1 max(sum(abs(x), axis=0)) as below
-1 min(sum(abs(x), axis=0)) as below
2 2-norm (largest sing. value) as below
-2 smallest singular value as below
other – sum(abs(x)**ord)**(1./ord)   The Frobenius norm is given by [1]: \(||A||_F = [\sum_{i,j} abs(a_{i,j})^2]^{1/2}\) The nuclear norm is the sum of the singular values. Both the Frobenius and nuclear norm orders are only defined for matrices and raise a ValueError when x.ndim != 2. References  1
G. H. Golub and C. F. Van Loan, Matrix Computations, Baltimore, MD, Johns Hopkins University Press, 1985, pg. 15   Examples >>> from numpy import linalg as LA
>>> a = np.arange(9) - 4
>>> a
array([-4, -3, -2, ...,  2,  3,  4])
>>> b = a.reshape((3, 3))
>>> b
array([[-4, -3, -2],
       [-1,  0,  1],
       [ 2,  3,  4]])
 >>> LA.norm(a)
7.745966692414834
>>> LA.norm(b)
7.745966692414834
>>> LA.norm(b, 'fro')
7.745966692414834
>>> LA.norm(a, np.inf)
4.0
>>> LA.norm(b, np.inf)
9.0
>>> LA.norm(a, -np.inf)
0.0
>>> LA.norm(b, -np.inf)
2.0
 >>> LA.norm(a, 1)
20.0
>>> LA.norm(b, 1)
7.0
>>> LA.norm(a, -1)
-4.6566128774142013e-010
>>> LA.norm(b, -1)
6.0
>>> LA.norm(a, 2)
7.745966692414834
>>> LA.norm(b, 2)
7.3484692283495345
 >>> LA.norm(a, -2)
0.0
>>> LA.norm(b, -2)
1.8570331885190563e-016 # may vary
>>> LA.norm(a, 3)
5.8480354764257312 # may vary
>>> LA.norm(a, -3)
0.0
 Using the axis argument to compute vector norms: >>> c = np.array([[ 1, 2, 3],
...               [-1, 1, 4]])
>>> LA.norm(c, axis=0)
array([ 1.41421356,  2.23606798,  5.        ])
>>> LA.norm(c, axis=1)
array([ 3.74165739,  4.24264069])
>>> LA.norm(c, ord=1, axis=1)
array([ 6.,  6.])
 Using the axis argument to compute matrix norms: >>> m = np.arange(8).reshape(2,2,2)
>>> LA.norm(m, axis=(1,2))
array([  3.74165739,  11.22497216])
>>> LA.norm(m[0, :, :]), LA.norm(m[1, :, :])
(3.7416573867739413, 11.224972160321824)


numpy.linalg.pinv   linalg.pinv(a, rcond=1e-15, hermitian=False)[source]

Compute the (Moore-Penrose) pseudo-inverse of a matrix. Calculate the generalized inverse of a matrix using its singular-value decomposition (SVD) and including all large singular values.  Changed in version 1.14: Can now operate on stacks of matrices   Parameters

a(…, M, N) array_like

Matrix or stack of matrices to be pseudo-inverted.
rcond(…) array_like of float

Cutoff for small singular values. Singular values less than or equal to rcond * largest_singular_value are set to zero. Broadcasts against the stack of matrices.
hermitianbool, optional

If True, a is assumed to be Hermitian (symmetric if real-valued), enabling a more efficient method for finding singular values. Defaults to False.  New in version 1.17.0.     Returns

B(…, N, M) ndarray

The pseudo-inverse of a. If a is a matrix instance, then so is B.    Raises
 LinAlgError

If the SVD computation does not converge.      See also  scipy.linalg.pinv

Similar function in SciPy.  scipy.linalg.pinv2

Similar function in SciPy (SVD-based).  scipy.linalg.pinvh

Compute the (Moore-Penrose) pseudo-inverse of a Hermitian matrix.    Notes The pseudo-inverse of a matrix A, denoted \(A^+\), is defined as: “the matrix that ‘solves’ [the least-squares problem] \(Ax = b\),” i.e., if \(\bar{x}\) is said solution, then \(A^+\) is that matrix such that \(\bar{x} = A^+b\). It can be shown that if \(Q_1 \Sigma Q_2^T = A\) is the singular value decomposition of A, then \(A^+ = Q_2 \Sigma^+ Q_1^T\), where \(Q_{1,2}\) are orthogonal matrices, \(\Sigma\) is a diagonal matrix consisting of A’s so-called singular values, (followed, typically, by zeros), and then \(\Sigma^+\) is simply the diagonal matrix consisting of the reciprocals of A’s singular values (again, followed by zeros). [1] References  1
G. Strang, Linear Algebra and Its Applications, 2nd Ed., Orlando, FL, Academic Press, Inc., 1980, pp. 139-142.   Examples The following example checks that a * a+ * a == a and a+ * a * a+ == a+: >>> a = np.random.randn(9, 6)
>>> B = np.linalg.pinv(a)
>>> np.allclose(a, np.dot(a, np.dot(B, a)))
True
>>> np.allclose(B, np.dot(B, np.dot(a, B)))
True


numpy.linalg.qr   linalg.qr(a, mode='reduced')[source]

Compute the qr factorization of a matrix. Factor the matrix a as qr, where q is orthonormal and r is upper-triangular.  Parameters

aarray_like, shape (…, M, N)

An array-like object with the dimensionality of at least 2.
mode{‘reduced’, ‘complete’, ‘r’, ‘raw’}, optional

If K = min(M, N), then
 ‘reduced’returns q, r with dimensions

(…, M, K), (…, K, N) (default)    ‘complete’ : returns q, r with dimensions (…, M, M), (…, M, N) ‘r’ : returns r only with dimensions (…, K, N) ‘raw’ : returns h, tau with dimensions (…, N, M), (…, K,)  The options ‘reduced’, ‘complete, and ‘raw’ are new in numpy 1.8, see the notes for more information. The default is ‘reduced’, and to maintain backward compatibility with earlier versions of numpy both it and the old default ‘full’ can be omitted. Note that array h returned in ‘raw’ mode is transposed for calling Fortran. The ‘economic’ mode is deprecated. The modes ‘full’ and ‘economic’ may be passed using only the first letter for backwards compatibility, but all others must be spelled out. See the Notes for more explanation.    Returns

qndarray of float or complex, optional

A matrix with orthonormal columns. When mode = ‘complete’ the result is an orthogonal/unitary matrix depending on whether or not a is real/complex. The determinant may be either +/- 1 in that case. In case the number of dimensions in the input array is greater than 2 then a stack of the matrices with above properties is returned.
rndarray of float or complex, optional

The upper-triangular matrix or a stack of upper-triangular matrices if the number of dimensions in the input array is greater than 2.
(h, tau)ndarrays of np.double or np.cdouble, optional

The array h contains the Householder reflectors that generate q along with r. The tau array contains scaling factors for the reflectors. In the deprecated ‘economic’ mode only h is returned.    Raises
 LinAlgError

If factoring fails.      See also  scipy.linalg.qr

Similar function in SciPy.  scipy.linalg.rq

Compute RQ decomposition of a matrix.    Notes This is an interface to the LAPACK routines dgeqrf, zgeqrf, dorgqr, and zungqr. For more information on the qr factorization, see for example: https://en.wikipedia.org/wiki/QR_factorization Subclasses of ndarray are preserved except for the ‘raw’ mode. So if a is of type matrix, all the return values will be matrices too. New ‘reduced’, ‘complete’, and ‘raw’ options for mode were added in NumPy 1.8.0 and the old option ‘full’ was made an alias of ‘reduced’. In addition the options ‘full’ and ‘economic’ were deprecated. Because ‘full’ was the previous default and ‘reduced’ is the new default, backward compatibility can be maintained by letting mode default. The ‘raw’ option was added so that LAPACK routines that can multiply arrays by q using the Householder reflectors can be used. Note that in this case the returned arrays are of type np.double or np.cdouble and the h array is transposed to be FORTRAN compatible. No routines using the ‘raw’ return are currently exposed by numpy, but some are available in lapack_lite and just await the necessary work. Examples >>> a = np.random.randn(9, 6)
>>> q, r = np.linalg.qr(a)
>>> np.allclose(a, np.dot(q, r))  # a does equal qr
True
>>> r2 = np.linalg.qr(a, mode='r')
>>> np.allclose(r, r2)  # mode='r' returns the same r as mode='full'
True
>>> a = np.random.normal(size=(3, 2, 2)) # Stack of 2 x 2 matrices as input
>>> q, r = np.linalg.qr(a)
>>> q.shape
(3, 2, 2)
>>> r.shape
(3, 2, 2)
>>> np.allclose(a, np.matmul(q, r))
True
 Example illustrating a common use of qr: solving of least squares problems What are the least-squares-best m and y0 in y = y0 + mx for the following data: {(0,1), (1,0), (1,2), (2,1)}. (Graph the points and you’ll see that it should be y0 = 0, m = 1.) The answer is provided by solving the over-determined matrix equation Ax = b, where: A = array([[0, 1], [1, 1], [1, 1], [2, 1]])
x = array([[y0], [m]])
b = array([[1], [0], [2], [1]])
 If A = qr such that q is orthonormal (which is always possible via Gram-Schmidt), then x = inv(r) * (q.T) * b. (In numpy practice, however, we simply use lstsq.) >>> A = np.array([[0, 1], [1, 1], [1, 1], [2, 1]])
>>> A
array([[0, 1],
       [1, 1],
       [1, 1],
       [2, 1]])
>>> b = np.array([1, 0, 2, 1])
>>> q, r = np.linalg.qr(A)
>>> p = np.dot(q.T, b)
>>> np.dot(np.linalg.inv(r), p)
array([  1.1e-16,   1.0e+00])


numpy.linalg.slogdet   linalg.slogdet(a)[source]

Compute the sign and (natural) logarithm of the determinant of an array. If an array has a very small or very large determinant, then a call to det may overflow or underflow. This routine is more robust against such issues, because it computes the logarithm of the determinant rather than the determinant itself.  Parameters

a(…, M, M) array_like

Input array, has to be a square 2-D array.    Returns

sign(…) array_like

A number representing the sign of the determinant. For a real matrix, this is 1, 0, or -1. For a complex matrix, this is a complex number with absolute value 1 (i.e., it is on the unit circle), or else 0.
logdet(…) array_like

The natural log of the absolute value of the determinant.  If the determinant is zero, then sign will be 0 and logdet will be
-Inf. In all cases, the determinant is equal to sign * np.exp(logdet).
    See also  det
  Notes  New in version 1.8.0.  Broadcasting rules apply, see the numpy.linalg documentation for details.  New in version 1.6.0.  The determinant is computed via LU factorization using the LAPACK routine z/dgetrf. Examples The determinant of a 2-D array [[a, b], [c, d]] is ad - bc: >>> a = np.array([[1, 2], [3, 4]])
>>> (sign, logdet) = np.linalg.slogdet(a)
>>> (sign, logdet)
(-1, 0.69314718055994529) # may vary
>>> sign * np.exp(logdet)
-2.0
 Computing log-determinants for a stack of matrices: >>> a = np.array([ [[1, 2], [3, 4]], [[1, 2], [2, 1]], [[1, 3], [3, 1]] ])
>>> a.shape
(3, 2, 2)
>>> sign, logdet = np.linalg.slogdet(a)
>>> (sign, logdet)
(array([-1., -1., -1.]), array([ 0.69314718,  1.09861229,  2.07944154]))
>>> sign * np.exp(logdet)
array([-2., -3., -8.])
 This routine succeeds where ordinary det does not: >>> np.linalg.det(np.eye(500) * 0.1)
0.0
>>> np.linalg.slogdet(np.eye(500) * 0.1)
(1, -1151.2925464970228)


numpy.linalg.solve   linalg.solve(a, b)[source]

Solve a linear matrix equation, or system of linear scalar equations. Computes the “exact” solution, x, of the well-determined, i.e., full rank, linear matrix equation ax = b.  Parameters

a(…, M, M) array_like

Coefficient matrix.
b{(…, M,), (…, M, K)}, array_like

Ordinate or “dependent variable” values.    Returns

x{(…, M,), (…, M, K)} ndarray

Solution to the system a x = b. Returned shape is identical to b.    Raises
 LinAlgError

If a is singular or not square.      See also  scipy.linalg.solve

Similar function in SciPy.    Notes  New in version 1.8.0.  Broadcasting rules apply, see the numpy.linalg documentation for details. The solutions are computed using LAPACK routine _gesv. a must be square and of full-rank, i.e., all rows (or, equivalently, columns) must be linearly independent; if either is not true, use lstsq for the least-squares best “solution” of the system/equation. References  1
G. Strang, Linear Algebra and Its Applications, 2nd Ed., Orlando, FL, Academic Press, Inc., 1980, pg. 22.   Examples Solve the system of equations x0 + 2 * x1 = 1 and 3 * x0 + 5 * x1 = 2: >>> a = np.array([[1, 2], [3, 5]])
>>> b = np.array([1, 2])
>>> x = np.linalg.solve(a, b)
>>> x
array([-1.,  1.])
 Check that the solution is correct: >>> np.allclose(np.dot(a, x), b)
True


numpy.linalg.svd   linalg.svd(a, full_matrices=True, compute_uv=True, hermitian=False)[source]

Singular Value Decomposition. When a is a 2D array, it is factorized as u @ np.diag(s) @ vh
= (u * s) @ vh, where u and vh are 2D unitary arrays and s is a 1D array of a’s singular values. When a is higher-dimensional, SVD is applied in stacked mode as explained below.  Parameters

a(…, M, N) array_like

A real or complex array with a.ndim >= 2.
full_matricesbool, optional

If True (default), u and vh have the shapes (..., M, M) and (..., N, N), respectively. Otherwise, the shapes are (..., M, K) and (..., K, N), respectively, where K = min(M, N).
compute_uvbool, optional

Whether or not to compute u and vh in addition to s. True by default.
hermitianbool, optional

If True, a is assumed to be Hermitian (symmetric if real-valued), enabling a more efficient method for finding singular values. Defaults to False.  New in version 1.17.0.     Returns

u{ (…, M, M), (…, M, K) } array

Unitary array(s). The first a.ndim - 2 dimensions have the same size as those of the input a. The size of the last two dimensions depends on the value of full_matrices. Only returned when compute_uv is True.
s(…, K) array

Vector(s) with the singular values, within each vector sorted in descending order. The first a.ndim - 2 dimensions have the same size as those of the input a.
vh{ (…, N, N), (…, K, N) } array

Unitary array(s). The first a.ndim - 2 dimensions have the same size as those of the input a. The size of the last two dimensions depends on the value of full_matrices. Only returned when compute_uv is True.    Raises
 LinAlgError

If SVD computation does not converge.      See also  scipy.linalg.svd

Similar function in SciPy.  scipy.linalg.svdvals

Compute singular values of a matrix.    Notes  Changed in version 1.8.0: Broadcasting rules apply, see the numpy.linalg documentation for details.  The decomposition is performed using LAPACK routine _gesdd. SVD is usually described for the factorization of a 2D matrix \(A\). The higher-dimensional case will be discussed below. In the 2D case, SVD is written as \(A = U S V^H\), where \(A = a\), \(U= u\), \(S= \mathtt{np.diag}(s)\) and \(V^H = vh\). The 1D array s contains the singular values of a and u and vh are unitary. The rows of vh are the eigenvectors of \(A^H A\) and the columns of u are the eigenvectors of \(A A^H\). In both cases the corresponding (possibly non-zero) eigenvalues are given by s**2. If a has more than two dimensions, then broadcasting rules apply, as explained in Linear algebra on several matrices at once. This means that SVD is working in “stacked” mode: it iterates over all indices of the first a.ndim - 2 dimensions and for each combination SVD is applied to the last two indices. The matrix a can be reconstructed from the decomposition with either (u * s[..., None, :]) @ vh or u @ (s[..., None] * vh). (The @ operator can be replaced by the function np.matmul for python versions below 3.5.) If a is a matrix object (as opposed to an ndarray), then so are all the return values. Examples >>> a = np.random.randn(9, 6) + 1j*np.random.randn(9, 6)
>>> b = np.random.randn(2, 7, 8, 3) + 1j*np.random.randn(2, 7, 8, 3)
 Reconstruction based on full SVD, 2D case: >>> u, s, vh = np.linalg.svd(a, full_matrices=True)
>>> u.shape, s.shape, vh.shape
((9, 9), (6,), (6, 6))
>>> np.allclose(a, np.dot(u[:, :6] * s, vh))
True
>>> smat = np.zeros((9, 6), dtype=complex)
>>> smat[:6, :6] = np.diag(s)
>>> np.allclose(a, np.dot(u, np.dot(smat, vh)))
True
 Reconstruction based on reduced SVD, 2D case: >>> u, s, vh = np.linalg.svd(a, full_matrices=False)
>>> u.shape, s.shape, vh.shape
((9, 6), (6,), (6, 6))
>>> np.allclose(a, np.dot(u * s, vh))
True
>>> smat = np.diag(s)
>>> np.allclose(a, np.dot(u, np.dot(smat, vh)))
True
 Reconstruction based on full SVD, 4D case: >>> u, s, vh = np.linalg.svd(b, full_matrices=True)
>>> u.shape, s.shape, vh.shape
((2, 7, 8, 8), (2, 7, 3), (2, 7, 3, 3))
>>> np.allclose(b, np.matmul(u[..., :3] * s[..., None, :], vh))
True
>>> np.allclose(b, np.matmul(u[..., :3], s[..., None] * vh))
True
 Reconstruction based on reduced SVD, 4D case: >>> u, s, vh = np.linalg.svd(b, full_matrices=False)
>>> u.shape, s.shape, vh.shape
((2, 7, 8, 3), (2, 7, 3), (2, 7, 3, 3))
>>> np.allclose(b, np.matmul(u * s[..., None, :], vh))
True
>>> np.allclose(b, np.matmul(u, s[..., None] * vh))
True


numpy.linalg.tensorinv   linalg.tensorinv(a, ind=2)[source]

Compute the ‘inverse’ of an N-dimensional array. The result is an inverse for a relative to the tensordot operation tensordot(a, b, ind), i. e., up to floating-point accuracy, tensordot(tensorinv(a), a, ind) is the “identity” tensor for the tensordot operation.  Parameters

aarray_like

Tensor to ‘invert’. Its shape must be ‘square’, i. e., prod(a.shape[:ind]) == prod(a.shape[ind:]).
indint, optional

Number of first indices that are involved in the inverse sum. Must be a positive integer, default is 2.    Returns

bndarray

a’s tensordot inverse, shape a.shape[ind:] + a.shape[:ind].    Raises
 LinAlgError

If a is singular or not ‘square’ (in the above sense).      See also
numpy.tensordot, tensorsolve

  Examples >>> a = np.eye(4*6)
>>> a.shape = (4, 6, 8, 3)
>>> ainv = np.linalg.tensorinv(a, ind=2)
>>> ainv.shape
(8, 3, 4, 6)
>>> b = np.random.randn(4, 6)
>>> np.allclose(np.tensordot(ainv, b), np.linalg.tensorsolve(a, b))
True
 >>> a = np.eye(4*6)
>>> a.shape = (24, 8, 3)
>>> ainv = np.linalg.tensorinv(a, ind=1)
>>> ainv.shape
(8, 3, 24)
>>> b = np.random.randn(24)
>>> np.allclose(np.tensordot(ainv, b, 1), np.linalg.tensorsolve(a, b))
True


numpy.linalg.tensorsolve   linalg.tensorsolve(a, b, axes=None)[source]

Solve the tensor equation a x = b for x. It is assumed that all indices of x are summed over in the product, together with the rightmost indices of a, as is done in, for example, tensordot(a, x, axes=b.ndim).  Parameters

aarray_like

Coefficient tensor, of shape b.shape + Q. Q, a tuple, equals the shape of that sub-tensor of a consisting of the appropriate number of its rightmost indices, and must be such that prod(Q) == prod(b.shape) (in which sense a is said to be ‘square’).
barray_like

Right-hand tensor, which can be of any shape.
axestuple of ints, optional

Axes in a to reorder to the right, before inversion. If None (default), no reordering is done.    Returns

xndarray, shape Q

  Raises
 LinAlgError

If a is singular or not ‘square’ (in the above sense).      See also
numpy.tensordot, tensorinv, numpy.einsum

  Examples >>> a = np.eye(2*3*4)
>>> a.shape = (2*3, 4, 2, 3, 4)
>>> b = np.random.randn(2*3, 4)
>>> x = np.linalg.tensorsolve(a, b)
>>> x.shape
(2, 3, 4)
>>> np.allclose(np.tensordot(a, x, axes=3), b)
True


numpy.ma.all   ma.all(self, axis=None, out=None, keepdims=<no value>) = <numpy.ma.core._frommethod object>

Returns True if all elements evaluate to True. The output array is masked where all the values along the given axis are masked: if the output would have been a scalar and that all the values are masked, then the output is masked. Refer to numpy.all for full documentation.  See also  numpy.ndarray.all

corresponding function for ndarrays  numpy.all

equivalent function    Examples >>> np.ma.array([1,2,3]).all()
True
>>> a = np.ma.array([1,2,3], mask=True)
>>> (a.all() is np.ma.masked)
True


numpy.ma.allclose   ma.allclose(a, b, masked_equal=True, rtol=1e-05, atol=1e-08)[source]

Returns True if two arrays are element-wise equal within a tolerance. This function is equivalent to allclose except that masked values are treated as equal (default) or unequal, depending on the masked_equal argument.  Parameters

a, barray_like

Input arrays to compare.
masked_equalbool, optional

Whether masked values in a and b are considered equal (True) or not (False). They are considered equal by default.
rtolfloat, optional

Relative tolerance. The relative difference is equal to rtol * b. Default is 1e-5.
atolfloat, optional

Absolute tolerance. The absolute difference is equal to atol. Default is 1e-8.    Returns

ybool

Returns True if the two arrays are equal within the given tolerance, False otherwise. If either array contains NaN, then False is returned.      See also
all, any

numpy.allclose

the non-masked allclose.    Notes If the following equation is element-wise True, then allclose returns True: absolute(`a` - `b`) <= (`atol` + `rtol` * absolute(`b`))
 Return True if all elements of a and b are equal subject to given tolerances. Examples >>> a = np.ma.array([1e10, 1e-7, 42.0], mask=[0, 0, 1])
>>> a
masked_array(data=[10000000000.0, 1e-07, --],
             mask=[False, False,  True],
       fill_value=1e+20)
>>> b = np.ma.array([1e10, 1e-8, -42.0], mask=[0, 0, 1])
>>> np.ma.allclose(a, b)
False
 >>> a = np.ma.array([1e10, 1e-8, 42.0], mask=[0, 0, 1])
>>> b = np.ma.array([1.00001e10, 1e-9, -42.0], mask=[0, 0, 1])
>>> np.ma.allclose(a, b)
True
>>> np.ma.allclose(a, b, masked_equal=False)
False
 Masked values are not compared directly. >>> a = np.ma.array([1e10, 1e-8, 42.0], mask=[0, 0, 1])
>>> b = np.ma.array([1.00001e10, 1e-9, 42.0], mask=[0, 0, 1])
>>> np.ma.allclose(a, b)
True
>>> np.ma.allclose(a, b, masked_equal=False)
False


numpy.ma.allequal   ma.allequal(a, b, fill_value=True)[source]

Return True if all entries of a and b are equal, using fill_value as a truth value where either or both are masked.  Parameters

a, barray_like

Input arrays to compare.
fill_valuebool, optional

Whether masked values in a or b are considered equal (True) or not (False).    Returns

ybool

Returns True if the two arrays are equal within the given tolerance, False otherwise. If either array contains NaN, then False is returned.      See also
all, any

numpy.ma.allclose
  Examples >>> a = np.ma.array([1e10, 1e-7, 42.0], mask=[0, 0, 1])
>>> a
masked_array(data=[10000000000.0, 1e-07, --],
             mask=[False, False,  True],
       fill_value=1e+20)
 >>> b = np.array([1e10, 1e-7, -42.0])
>>> b
array([  1.00000000e+10,   1.00000000e-07,  -4.20000000e+01])
>>> np.ma.allequal(a, b, fill_value=False)
False
>>> np.ma.allequal(a, b)
True


numpy.ma.anom   ma.anom(self, axis=None, dtype=None) = <numpy.ma.core._frommethod object>

Compute the anomalies (deviations from the arithmetic mean) along the given axis. Returns an array of anomalies, with the same shape as the input and where the arithmetic mean is computed along the given axis.  Parameters

axisint, optional

Axis over which the anomalies are taken. The default is to use the mean of the flattened array as reference.
dtypedtype, optional

 Type to use in computing the variance. For arrays of integer type

the default is float32; for arrays of float types it is the same as the array type.        See also  mean

Compute the mean of the array.    Examples >>> a = np.ma.array([1,2,3])
>>> a.anom()
masked_array(data=[-1.,  0.,  1.],
             mask=False,
       fill_value=1e+20)


numpy.ma.anomalies   ma.anomalies(self, axis=None, dtype=None) = <numpy.ma.core._frommethod object>

Compute the anomalies (deviations from the arithmetic mean) along the given axis. Returns an array of anomalies, with the same shape as the input and where the arithmetic mean is computed along the given axis.  Parameters

axisint, optional

Axis over which the anomalies are taken. The default is to use the mean of the flattened array as reference.
dtypedtype, optional

 Type to use in computing the variance. For arrays of integer type

the default is float32; for arrays of float types it is the same as the array type.        See also  mean

Compute the mean of the array.    Examples >>> a = np.ma.array([1,2,3])
>>> a.anom()
masked_array(data=[-1.,  0.,  1.],
             mask=False,
       fill_value=1e+20)


numpy.ma.any   ma.any(self, axis=None, out=None, keepdims=<no value>) = <numpy.ma.core._frommethod object>

Returns True if any of the elements of a evaluate to True. Masked values are considered as False during computation. Refer to numpy.any for full documentation.  See also  numpy.ndarray.any

corresponding function for ndarrays  numpy.any

equivalent function


numpy.ma.append   ma.append(a, b, axis=None)[source]

Append values to the end of an array.  New in version 1.9.0.   Parameters

aarray_like

Values are appended to a copy of this array.
barray_like

These values are appended to a copy of a. It must be of the correct shape (the same shape as a, excluding axis). If axis is not specified, b can be any shape and will be flattened before use.
axisint, optional

The axis along which v are appended. If axis is not given, both a and b are flattened before use.    Returns

appendMaskedArray

A copy of a with b appended to axis. Note that append does not occur in-place: a new array is allocated and filled. If axis is None, the result is a flattened array.      See also  numpy.append

Equivalent function in the top-level NumPy module.    Examples >>> import numpy.ma as ma
>>> a = ma.masked_values([1, 2, 3], 2)
>>> b = ma.masked_values([[4, 5, 6], [7, 8, 9]], 7)
>>> ma.append(a, b)
masked_array(data=[1, --, 3, 4, 5, 6, --, 8, 9],
             mask=[False,  True, False, False, False, False,  True, False,
                   False],
       fill_value=999999)


numpy.ma.apply_along_axis   ma.apply_along_axis(func1d, axis, arr, *args, **kwargs)[source]

Apply a function to 1-D slices along the given axis. Execute func1d(a, *args, **kwargs) where func1d operates on 1-D arrays and a is a 1-D slice of arr along axis. This is equivalent to (but faster than) the following use of ndindex and s_, which sets each of ii, jj, and kk to a tuple of indices: Ni, Nk = a.shape[:axis], a.shape[axis+1:]
for ii in ndindex(Ni):
    for kk in ndindex(Nk):
        f = func1d(arr[ii + s_[:,] + kk])
        Nj = f.shape
        for jj in ndindex(Nj):
            out[ii + jj + kk] = f[jj]
 Equivalently, eliminating the inner loop, this can be expressed as: Ni, Nk = a.shape[:axis], a.shape[axis+1:]
for ii in ndindex(Ni):
    for kk in ndindex(Nk):
        out[ii + s_[...,] + kk] = func1d(arr[ii + s_[:,] + kk])
  Parameters

func1dfunction (M,) -> (Nj…)

This function should accept 1-D arrays. It is applied to 1-D slices of arr along the specified axis.
axisinteger

Axis along which arr is sliced.
arrndarray (Ni…, M, Nk…)

Input array.
argsany

Additional arguments to func1d.
kwargsany

Additional named arguments to func1d.  New in version 1.9.0.     Returns

outndarray (Ni…, Nj…, Nk…)

The output array. The shape of out is identical to the shape of arr, except along the axis dimension. This axis is removed, and replaced with new dimensions equal to the shape of the return value of func1d. So if func1d returns a scalar out will have one fewer dimensions than arr.      See also  apply_over_axes

Apply a function repeatedly over multiple axes.    Examples >>> def my_func(a):
...     """Average first and last element of a 1-D array"""
...     return (a[0] + a[-1]) * 0.5
>>> b = np.array([[1,2,3], [4,5,6], [7,8,9]])
>>> np.apply_along_axis(my_func, 0, b)
array([4., 5., 6.])
>>> np.apply_along_axis(my_func, 1, b)
array([2.,  5.,  8.])
 For a function that returns a 1D array, the number of dimensions in outarr is the same as arr. >>> b = np.array([[8,1,7], [4,3,9], [5,2,6]])
>>> np.apply_along_axis(sorted, 1, b)
array([[1, 7, 8],
       [3, 4, 9],
       [2, 5, 6]])
 For a function that returns a higher dimensional array, those dimensions are inserted in place of the axis dimension. >>> b = np.array([[1,2,3], [4,5,6], [7,8,9]])
>>> np.apply_along_axis(np.diag, -1, b)
array([[[1, 0, 0],
        [0, 2, 0],
        [0, 0, 3]],
       [[4, 0, 0],
        [0, 5, 0],
        [0, 0, 6]],
       [[7, 0, 0],
        [0, 8, 0],
        [0, 0, 9]]])


numpy.ma.apply_over_axes   ma.apply_over_axes(func, a, axes)[source]

Apply a function repeatedly over multiple axes. func is called as res = func(a, axis), where axis is the first element of axes. The result res of the function call must have either the same dimensions as a or one less dimension. If res has one less dimension than a, a dimension is inserted before axis. The call to func is then repeated for each axis in axes, with res as the first argument.  Parameters

funcfunction

This function must take two arguments, func(a, axis).
aarray_like

Input array.
axesarray_like

Axes over which func is applied; the elements must be integers.    Returns

apply_over_axisndarray

The output array. The number of dimensions is the same as a, but the shape can be different. This depends on whether func changes the shape of its output with respect to its input.      See also  apply_along_axis

Apply a function to 1-D slices of an array along the given axis.    Examples >>> a = np.ma.arange(24).reshape(2,3,4)
>>> a[:,0,1] = np.ma.masked
>>> a[:,1,:] = np.ma.masked
>>> a
masked_array(
  data=[[[0, --, 2, 3],
         [--, --, --, --],
         [8, 9, 10, 11]],
        [[12, --, 14, 15],
         [--, --, --, --],
         [20, 21, 22, 23]]],
  mask=[[[False,  True, False, False],
         [ True,  True,  True,  True],
         [False, False, False, False]],
        [[False,  True, False, False],
         [ True,  True,  True,  True],
         [False, False, False, False]]],
  fill_value=999999)
>>> np.ma.apply_over_axes(np.ma.sum, a, [0,2])
masked_array(
  data=[[[46],
         [--],
         [124]]],
  mask=[[[False],
         [ True],
         [False]]],
  fill_value=999999)
 Tuple axis arguments to ufuncs are equivalent: >>> np.ma.sum(a, axis=(0,2)).reshape((1,-1,1))
masked_array(
  data=[[[46],
         [--],
         [124]]],
  mask=[[[False],
         [ True],
         [False]]],
  fill_value=999999)


numpy.ma.arange   ma.arange([start, ]stop, [step, ]dtype=None, *, like=None) = <numpy.ma.core._convert2ma object>

Return evenly spaced values within a given interval. Values are generated within the half-open interval [start, stop) (in other words, the interval including start but excluding stop). For integer arguments the function is equivalent to the Python built-in range function, but returns an ndarray rather than a list. When using a non-integer step, such as 0.1, it is often better to use numpy.linspace. See the warnings section below for more information.  Parameters

startinteger or real, optional

Start of interval. The interval includes this value. The default start value is 0.
stopinteger 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.
stepinteger 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.
dtypedtype

The type of the output array. If dtype is not given, infer the data type from the other input arguments.
likearray_like

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.  New in version 1.20.0.     Returns

arangeMaskedArray

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.      Warning 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.   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.    Examples >>> 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.ma.argmax   ma.argmax(self, axis=None, fill_value=None, out=None) = <numpy.ma.core._frommethod object>

Returns array of indices of the maximum values along the given axis. Masked values are treated as if they had the value fill_value.  Parameters

axis{None, integer}

If None, the index is into the flattened array, otherwise along the specified axis
fill_valuescalar or None, optional

Value used to fill in the masked values. If None, the output of maximum_fill_value(self._data) is used instead.
out{None, array}, optional

Array into which the result can be placed. Its type is preserved and it must be of the right shape to hold the output.    Returns

index_array{integer_array}

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


numpy.ma.argmin   ma.argmin(self, axis=None, fill_value=None, out=None) = <numpy.ma.core._frommethod object>

Return array of indices to the minimum values along the given axis.  Parameters

axis{None, integer}

If None, the index is into the flattened array, otherwise along the specified axis
fill_valuescalar or None, optional

Value used to fill in the masked values. If None, the output of minimum_fill_value(self._data) is used instead.
out{None, array}, optional

Array into which the result can be placed. Its type is preserved and it must be of the right shape to hold the output.    Returns
 ndarray or scalar

If multi-dimension input, returns a new ndarray of indices to the minimum values along the given axis. Otherwise, returns a scalar of index to the minimum values along the given axis.     Examples >>> x = np.ma.array(np.arange(4), mask=[1,1,0,0])
>>> x.shape = (2,2)
>>> x
masked_array(
  data=[[--, --],
        [2, 3]],
  mask=[[ True,  True],
        [False, False]],
  fill_value=999999)
>>> x.argmin(axis=0, fill_value=-1)
array([0, 0])
>>> x.argmin(axis=0, fill_value=9)
array([1, 1])


numpy.ma.argsort   ma.argsort(a, axis=<no value>, kind=None, order=None, endwith=True, fill_value=None)[source]

Return an ndarray of indices that sort the array along the specified axis. Masked values are filled beforehand to fill_value.  Parameters

axisint, optional

Axis along which to sort. If None, the default, the flattened array is used.  Changed in version 1.13.0: Previously, the default was documented to be -1, but that was in error. At some future date, the default will change to -1, as originally intended. Until then, the axis should be given explicitly when arr.ndim > 1, to avoid a FutureWarning.
kind{‘quicksort’, ‘mergesort’, ‘heapsort’, ‘stable’}, optional

The sorting algorithm used.
orderlist, optional

When a is an array with fields defined, this argument specifies which fields to compare first, second, etc. Not all fields need be specified.
endwith{True, False}, optional

Whether missing values (if any) should be treated as the largest values (True) or the smallest values (False) When the array contains unmasked values at the same extremes of the datatype, the ordering of these values and the masked values is undefined.
fill_valuescalar or None, optional

Value used internally for the masked values. If fill_value is not None, it supersedes endwith.    Returns

index_arrayndarray, int

Array of indices that sort a along the specified axis. In other words, a[index_array] yields a sorted a.      See also  ma.MaskedArray.sort

Describes sorting algorithms used.  lexsort

Indirect stable sort with multiple keys.  numpy.ndarray.sort

Inplace sort.    Notes See sort for notes on the different sorting algorithms. Examples >>> a = np.ma.array([3,2,1], mask=[False, False, True])
>>> a
masked_array(data=[3, 2, --],
             mask=[False, False,  True],
       fill_value=999999)
>>> a.argsort()
array([1, 0, 2])


numpy.ma.around   ma.around = <numpy.ma.core._MaskedUnaryOperation object>

Round an array to the given number of decimals.  See also  around

equivalent function; see for details.


numpy.ma.array   ma.array(data, dtype=None, copy=False, order=None, mask=False, fill_value=None, keep_mask=True, hard_mask=False, shrink=True, subok=True, ndmin=0)[source]

An array class with possibly masked values. Masked values of True exclude the corresponding element from any computation. Construction: x = MaskedArray(data, mask=nomask, dtype=None, copy=False, subok=True,
                ndmin=0, fill_value=None, keep_mask=True, hard_mask=None,
                shrink=True, order=None)
  Parameters

dataarray_like

Input data.
masksequence, optional

Mask. Must be convertible to an array of booleans with the same shape as data. True indicates a masked (i.e. invalid) data.
dtypedtype, optional

Data type of the output. If dtype is None, the type of the data argument (data.dtype) is used. If dtype is not None and different from data.dtype, a copy is performed.
copybool, optional

Whether to copy the input data (True), or to use a reference instead. Default is False.
subokbool, optional

Whether to return a subclass of MaskedArray if possible (True) or a plain MaskedArray. Default is True.
ndminint, optional

Minimum number of dimensions. Default is 0.
fill_valuescalar, optional

Value used to fill in the masked values when necessary. If None, a default based on the data-type is used.
keep_maskbool, optional

Whether to combine mask with the mask of the input data, if any (True), or to use only mask for the output (False). Default is True.
hard_maskbool, optional

Whether to use a hard mask or not. With a hard mask, masked values cannot be unmasked. Default is False.
shrinkbool, optional

Whether to force compression of an empty mask. Default is True.
order{‘C’, ‘F’, ‘A’}, optional

Specify the order of the array. If order is ‘C’, then the array will be in C-contiguous order (last-index varies the fastest). If order is ‘F’, then the returned array will be in Fortran-contiguous order (first-index varies the fastest). If order is ‘A’ (default), then the returned array may be in any order (either C-, Fortran-contiguous, or even discontiguous), unless a copy is required, in which case it will be C-contiguous.     Examples The mask can be initialized with an array of boolean values with the same shape as data. >>> data = np.arange(6).reshape((2, 3))
>>> np.ma.MaskedArray(data, mask=[[False, True, False],
...                               [False, False, True]])
masked_array(
  data=[[0, --, 2],
        [3, 4, --]],
  mask=[[False,  True, False],
        [False, False,  True]],
  fill_value=999999)
 Alternatively, the mask can be initialized to homogeneous boolean array with the same shape as data by passing in a scalar boolean value: >>> np.ma.MaskedArray(data, mask=False)
masked_array(
  data=[[0, 1, 2],
        [3, 4, 5]],
  mask=[[False, False, False],
        [False, False, False]],
  fill_value=999999)
 >>> np.ma.MaskedArray(data, mask=True)
masked_array(
  data=[[--, --, --],
        [--, --, --]],
  mask=[[ True,  True,  True],
        [ True,  True,  True]],
  fill_value=999999,
  dtype=int64)
  Note The recommended practice for initializing mask with a scalar boolean value is to use True/False rather than np.True_/np.False_. The reason is nomask is represented internally as np.False_. >>> np.False_ is np.ma.nomask
True


numpy.ma.asanyarray   ma.asanyarray(a, dtype=None)[source]

Convert the input to a masked array, conserving subclasses. If a is a subclass of MaskedArray, its class is conserved. No copy is performed if the input is already an ndarray.  Parameters

aarray_like

Input data, in any form that can be converted to an array.
dtypedtype, optional

By default, the data-type is inferred from the input data.
order{‘C’, ‘F’}, optional

Whether to use row-major (‘C’) or column-major (‘FORTRAN’) memory representation. Default is ‘C’.    Returns

outMaskedArray

MaskedArray interpretation of a.      See also  asarray

Similar to asanyarray, but does not conserve subclass.    Examples >>> x = np.arange(10.).reshape(2, 5)
>>> x
array([[0., 1., 2., 3., 4.],
       [5., 6., 7., 8., 9.]])
>>> np.ma.asanyarray(x)
masked_array(
  data=[[0., 1., 2., 3., 4.],
        [5., 6., 7., 8., 9.]],
  mask=False,
  fill_value=1e+20)
>>> type(np.ma.asanyarray(x))
<class 'numpy.ma.core.MaskedArray'>


numpy.ma.asarray   ma.asarray(a, dtype=None, order=None)[source]

Convert the input to a masked array of the given data-type. No copy is performed if the input is already an ndarray. If a is a subclass of MaskedArray, a base class MaskedArray is returned.  Parameters

aarray_like

Input data, in any form that can be converted to a masked array. This includes lists, lists of tuples, tuples, tuples of tuples, tuples of lists, ndarrays and masked arrays.
dtypedtype, optional

By default, the data-type is inferred from the input data.
order{‘C’, ‘F’}, optional

Whether to use row-major (‘C’) or column-major (‘FORTRAN’) memory representation. Default is ‘C’.    Returns

outMaskedArray

Masked array interpretation of a.      See also  asanyarray

Similar to asarray, but conserves subclasses.    Examples >>> x = np.arange(10.).reshape(2, 5)
>>> x
array([[0., 1., 2., 3., 4.],
       [5., 6., 7., 8., 9.]])
>>> np.ma.asarray(x)
masked_array(
  data=[[0., 1., 2., 3., 4.],
        [5., 6., 7., 8., 9.]],
  mask=False,
  fill_value=1e+20)
>>> type(np.ma.asarray(x))
<class 'numpy.ma.core.MaskedArray'>


numpy.ma.atleast_1d   ma.atleast_1d(*args, **kwargs) = <numpy.ma.extras._fromnxfunction_allargs object>

Convert inputs to arrays with at least one dimension. Scalar inputs are converted to 1-dimensional arrays, whilst higher-dimensional inputs are preserved.  Parameters

arys1, arys2, …array_like

One or more input arrays.    Returns

retndarray

An array, or list of arrays, each with a.ndim >= 1. Copies are made only if necessary.      See also
atleast_2d, atleast_3d

  Notes The function is applied to both the _data and the _mask, if any. Examples >>> np.atleast_1d(1.0)
array([1.])
 >>> x = np.arange(9.0).reshape(3,3)
>>> np.atleast_1d(x)
array([[0., 1., 2.],
       [3., 4., 5.],
       [6., 7., 8.]])
>>> np.atleast_1d(x) is x
True
 >>> np.atleast_1d(1, [3, 4])
[array([1]), array([3, 4])]


numpy.ma.atleast_2d   ma.atleast_2d(*args, **kwargs) = <numpy.ma.extras._fromnxfunction_allargs object>

View inputs as arrays with at least two dimensions.  Parameters

arys1, arys2, …array_like

One or more array-like sequences. Non-array inputs are converted to arrays. Arrays that already have two or more dimensions are preserved.    Returns

res, res2, …ndarray

An array, or list of arrays, each with a.ndim >= 2. Copies are avoided where possible, and views with two or more dimensions are returned.      See also
atleast_1d, atleast_3d

  Notes The function is applied to both the _data and the _mask, if any. Examples >>> np.atleast_2d(3.0)
array([[3.]])
 >>> x = np.arange(3.0)
>>> np.atleast_2d(x)
array([[0., 1., 2.]])
>>> np.atleast_2d(x).base is x
True
 >>> np.atleast_2d(1, [1, 2], [[1, 2]])
[array([[1]]), array([[1, 2]]), array([[1, 2]])]


numpy.ma.atleast_3d   ma.atleast_3d(*args, **kwargs) = <numpy.ma.extras._fromnxfunction_allargs object>

View inputs as arrays with at least three dimensions.  Parameters

arys1, arys2, …array_like

One or more array-like sequences. Non-array inputs are converted to arrays. Arrays that already have three or more dimensions are preserved.    Returns

res1, res2, …ndarray

An array, or list of arrays, each with a.ndim >= 3. Copies are avoided where possible, and views with three or more dimensions are returned. For example, a 1-D array of shape (N,) becomes a view of shape (1, N, 1), and a 2-D array of shape (M, N) becomes a view of shape (M, N, 1).      See also
atleast_1d, atleast_2d

  Notes The function is applied to both the _data and the _mask, if any. Examples >>> np.atleast_3d(3.0)
array([[[3.]]])
 >>> x = np.arange(3.0)
>>> np.atleast_3d(x).shape
(1, 3, 1)
 >>> x = np.arange(12.0).reshape(4,3)
>>> np.atleast_3d(x).shape
(4, 3, 1)
>>> np.atleast_3d(x).base is x.base  # x is a reshape, so not base itself
True
 >>> for arr in np.atleast_3d([1, 2], [[1, 2]], [[[1, 2]]]):
...     print(arr, arr.shape)
...
[[[1]
  [2]]] (1, 2, 1)
[[[1]
  [2]]] (1, 2, 1)
[[[1 2]]] (1, 1, 2)


numpy.ma.average   ma.average(a, axis=None, weights=None, returned=False)[source]

Return the weighted average of array over the given axis.  Parameters

aarray_like

Data to be averaged. Masked entries are not taken into account in the computation.
axisint, optional

Axis along which to average a. If None, averaging is done over the flattened array.
weightsarray_like, optional

The importance that each element has in the computation of the average. The weights array can either be 1-D (in which case its length must be the size of a along the given axis) or of the same shape as a. If weights=None, then all data in a are assumed to have a weight equal to one. The 1-D calculation is: avg = sum(a * weights) / sum(weights)
 The only constraint on weights is that sum(weights) must not be 0.
returnedbool, optional

Flag indicating whether a tuple (result, sum of weights) should be returned as output (True), or just the result (False). Default is False.    Returns

average, [sum_of_weights](tuple of) scalar or MaskedArray

The average along the specified axis. When returned is True, return a tuple with the average as the first element and the sum of the weights as the second element. The return type is np.float64 if a is of integer type and floats smaller than float64, or the input data-type, otherwise. If returned, sum_of_weights is always float64.     Examples >>> a = np.ma.array([1., 2., 3., 4.], mask=[False, False, True, True])
>>> np.ma.average(a, weights=[3, 1, 0, 0])
1.25
 >>> x = np.ma.arange(6.).reshape(3, 2)
>>> x
masked_array(
  data=[[0., 1.],
        [2., 3.],
        [4., 5.]],
  mask=False,
  fill_value=1e+20)
>>> avg, sumweights = np.ma.average(x, axis=0, weights=[1, 2, 3],
...                                 returned=True)
>>> avg
masked_array(data=[2.6666666666666665, 3.6666666666666665],
             mask=[False, False],
       fill_value=1e+20)


numpy.ma.choose   ma.choose(indices, choices, out=None, mode='raise')[source]

Use an index array to construct a new array from a list of choices. Given an array of integers and a list of n choice arrays, this method will create a new array that merges each of the choice arrays. Where a value in index is i, the new array will have the value that choices[i] contains in the same place.  Parameters

indicesndarray of ints

This array must contain integers in [0, n-1], where n is the number of choices.
choicessequence of arrays

Choice arrays. The index array and all of the choices should be broadcastable to the same shape.
outarray, optional

If provided, the result will be inserted into this array. It should be of the appropriate shape and dtype.
mode{‘raise’, ‘wrap’, ‘clip’}, optional

Specifies how out-of-bounds indices will behave.  ‘raise’ : raise an error ‘wrap’ : wrap around ‘clip’ : clip to the range     Returns

merged_arrayarray

    See also  choose

equivalent function    Examples >>> choice = np.array([[1,1,1], [2,2,2], [3,3,3]])
>>> a = np.array([2, 1, 0])
>>> np.ma.choose(a, choice)
masked_array(data=[3, 2, 1],
             mask=False,
       fill_value=999999)