package scipy

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 ---------- data : array_like Input data. mask : sequence, optional Mask. Must be convertible to an array of booleans with the same shape as `data`. True indicates a masked (i.e. invalid) data. dtype : dtype, 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. copy : bool, optional Whether to copy the input data (True), or to use a reference instead. Default is False. subok : bool, optional Whether to return a subclass of `MaskedArray` if possible (True) or a plain `MaskedArray`. Default is True. ndmin : int, optional Minimum number of dimensions. Default is 0. fill_value : scalar, optional Value used to fill in the masked values when necessary. If None, a default based on the data-type is used. keep_mask : bool, 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_mask : bool, optional Whether to use a hard mask or not. With a hard mask, masked values cannot be unmasked. Default is False. shrink : bool, 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.

x.__getitem__(y) <==> xy

Return the item described by i, as a masked array.

Implement iter(self).

x.__setitem__(i, y) <==> xi=y

Set item described by index. If value is masked, masks those locations.

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

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 ---------- axis : int, optional Axis over which the anomalies are taken. The default is to use the mean of the flattened array as reference. dtype : dtype, 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)

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

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_value :

ar}, 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])

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_value :

ar}, 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])

a.argpartition(kth, axis=-1, kind='introselect', order=None)

Returns the indices that would partition this array.

Refer to `numpy.argpartition` for full documentation.

.. versionadded:: 1.8.0

See Also -------- numpy.argpartition : equivalent function

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

Parameters ---------- axis : int, optional Axis along which to sort. If None, the default, the flattened array is used.

.. versionchanged:: 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. order : list, 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_value :

ar}, optional
    Value used internally for the masked values.
    If ``fill_value`` is not None, it supersedes ``endwith``.

Returns
-------
index_array : ndarray, int
    Array of indices that sort `a` along the specified axis.
    In other words, ``a[index_array]`` yields a sorted `a`.

See Also
--------
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])

a.astype(dtype, order='K', casting='unsafe', subok=True, copy=True)

Copy of the array, cast to a specified type.

Parameters ---------- dtype : str or dtype Typecode or data-type to which the array is cast. order : 'C', 'F', 'A', 'K', optional Controls the memory layout order of the result. 'C' means C order, 'F' means Fortran order, 'A' means 'F' order if all the arrays are Fortran contiguous, 'C' order otherwise, and 'K' means as close to the order the array elements appear in memory as possible. Default is 'K'. casting : 'no', 'equiv', 'safe', 'same_kind', 'unsafe', optional Controls what kind of data casting may occur. Defaults to 'unsafe' for backwards compatibility.

* 'no' means the data types should not be cast at all. * 'equiv' means only byte-order changes are allowed. * 'safe' means only casts which can preserve values are allowed. * 'same_kind' means only safe casts or casts within a kind, like float64 to float32, are allowed. * 'unsafe' means any data conversions may be done. subok : bool, optional If True, then sub-classes will be passed-through (default), otherwise the returned array will be forced to be a base-class array. copy : bool, optional By default, astype always returns a newly allocated array. If this is set to false, and the `dtype`, `order`, and `subok` requirements are satisfied, the input array is returned instead of a copy.

Returns ------- arr_t : ndarray Unless `copy` is False and the other conditions for returning the input array are satisfied (see description for `copy` input parameter), `arr_t` is a new array of the same shape as the input array, with dtype, order given by `dtype`, `order`.

Notes ----- .. versionchanged:: 1.17.0 Casting between a simple data type and a structured one is possible only for 'unsafe' casting. Casting to multiple fields is allowed, but casting from multiple fields is not.

.. versionchanged:: 1.9.0 Casting from numeric to string types in 'safe' casting mode requires that the string dtype length is long enough to store the max integer/float value converted.

Raises ------ ComplexWarning When casting from complex to float or int. To avoid this, one should use ``a.real.astype(t)``.

Examples -------- >>> x = np.array(1, 2, 2.5) >>> x array(1. , 2. , 2.5)

>>> x.astype(int) array(1, 2, 2)

a.byteswap(inplace=False)

Swap the bytes of the array elements

Toggle between low-endian and big-endian data representation by returning a byteswapped array, optionally swapped in-place. Arrays of byte-strings are not swapped. The real and imaginary parts of a complex number are swapped individually.

Parameters ---------- inplace : bool, optional If ``True``, swap bytes in-place, default is ``False``.

Returns ------- out : ndarray The byteswapped array. If `inplace` is ``True``, this is a view to self.

Examples -------- >>> A = np.array(1, 256, 8755, dtype=np.int16) >>> list(map(hex, A)) '0x1', '0x100', '0x2233' >>> A.byteswap(inplace=True) array( 256, 1, 13090, dtype=int16) >>> list(map(hex, A)) '0x100', '0x1', '0x3322'

Arrays of byte-strings are not swapped

>>> A = np.array(b'ceg', b'fac') >>> A.byteswap() array(b'ceg', b'fac', dtype='|S3')

``A.newbyteorder().byteswap()`` produces an array with the same values but different representation in memory

>>> A = np.array(1, 2, 3) >>> A.view(np.uint8) array(1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, dtype=uint8) >>> A.newbyteorder().byteswap(inplace=True) array(1, 2, 3) >>> A.view(np.uint8) array(0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 3, dtype=uint8)

a.choose(choices, out=None, mode='raise')

Use an index array to construct a new array from a set of choices.

Refer to `numpy.choose` for full documentation.

See Also -------- numpy.choose : equivalent function

a.clip(min=None, max=None, out=None, **kwargs)

Return an array whose values are limited to ``min, max``. One of max or min must be given.

Refer to `numpy.clip` for full documentation.

See Also -------- numpy.clip : equivalent function

Return `a` where condition is ``True``.

If condition is a `MaskedArray`, missing values are considered as ``False``.

Parameters ---------- condition : var Boolean 1-d array selecting which entries to return. If len(condition) is less than the size of a along the axis, then output is truncated to length of condition array. axis : None, int, optional Axis along which the operation must be performed. out : None, ndarray, optional Alternative output array in which to place the result. It must have the same shape as the expected output but the type will be cast if necessary.

Returns ------- result : MaskedArray A :class:`MaskedArray` object.

Notes ----- Please note the difference with :meth:`compressed` ! The output of :meth:`compress` has a mask, the output of :meth:`compressed` does not.

Examples -------- >>> x = np.ma.array([1,2,3],[4,5,6],[7,8,9], mask=0 + 1,0*4) >>> x masked_array( data=[1, --, 3], [--, 5, --], [7, --, 9], mask=[False, True, False], [ True, False, True], [False, True, False], fill_value=999999) >>> x.compress(1, 0, 1) masked_array(data=1, 3, mask=False, False, fill_value=999999)

>>> x.compress(1, 0, 1, axis=1) masked_array( data=[1, 3], [--, --], [7, 9], mask=[False, False], [ True, True], [False, False], fill_value=999999)

Return all the non-masked data as a 1-D array.

Returns ------- data : ndarray A new `ndarray` holding the non-masked data is returned.

Notes ----- The result is **not** a MaskedArray!

Examples -------- >>> x = np.ma.array(np.arange(5), mask=0*2 + 1*3) >>> x.compressed() array(0, 1) >>> type(x.compressed()) <class 'numpy.ndarray'>

a.copy(order='C')

Return a copy of the array.

Parameters ---------- order : 'C', 'F', 'A', 'K', optional Controls the memory layout of the copy. 'C' means C-order, 'F' means F-order, 'A' means 'F' if `a` is Fortran contiguous, 'C' otherwise. 'K' means match the layout of `a` as closely as possible. (Note that this function and :func:`numpy.copy` are very similar, but have different default values for their order= arguments.)

See also -------- numpy.copy numpy.copyto

Examples -------- >>> x = np.array([1,2,3],[4,5,6], order='F')

>>> y = x.copy()

>>> x.fill(0)

>>> x array([0, 0, 0], [0, 0, 0])

>>> y array([1, 2, 3], [4, 5, 6])

>>> y.flags'C_CONTIGUOUS' True

Count the non-masked elements of the array along the given axis.

Parameters ---------- axis : None or int or tuple of ints, optional Axis or axes along which the count is performed. The default, None, performs the count over all the dimensions of the input array. `axis` may be negative, in which case it counts from the last to the first axis.

.. versionadded:: 1.10.0

If this is a tuple of ints, the count is performed on multiple axes, instead of a single axis or all the axes as before. keepdims : bool, optional If this is set to True, the axes which are reduced are left in the result as dimensions with size one. With this option, the result will broadcast correctly against the array.

Returns ------- result : ndarray or scalar An array with the same shape as the input array, with the specified axis removed. If the array is a 0-d array, or if `axis` is None, a scalar is returned.

See Also -------- count_masked : Count masked elements in array or along a given axis.

Examples -------- >>> import numpy.ma as ma >>> a = ma.arange(6).reshape((2, 3)) >>> a1, : = ma.masked >>> a masked_array( data=[0, 1, 2], [--, --, --], mask=[False, False, False], [ True, True, True], fill_value=999999) >>> a.count() 3

When the `axis` keyword is specified an array of appropriate size is returned.

>>> a.count(axis=0) array(1, 1, 1) >>> a.count(axis=1) array(3, 0)

Return the cumulative product of the array elements over the given axis.

Masked values are set to 1 internally during the computation. However, their position is saved, and the result will be masked at the same locations.

Refer to `numpy.cumprod` for full documentation.

Notes ----- The mask is lost if `out` is not a valid MaskedArray !

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

See Also -------- numpy.ndarray.cumprod : corresponding function for ndarrays numpy.cumprod : equivalent function

Return the cumulative sum of the array elements over the given axis.

Masked values are set to 0 internally during the computation. However, their position is saved, and the result will be masked at the same locations.

Refer to `numpy.cumsum` for full documentation.

Notes ----- The mask is lost if `out` is not a valid :class:`MaskedArray` !

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

See Also -------- numpy.ndarray.cumsum : corresponding function for ndarrays numpy.cumsum : equivalent function

Examples -------- >>> marr = np.ma.array(np.arange(10), mask=0,0,0,1,1,1,0,0,0,0) >>> marr.cumsum() masked_array(data=0, 1, 3, --, --, --, 9, 16, 24, 33, mask=False, False, False, True, True, True, False, False, False, False, fill_value=999999)

a.diagonal(offset=0, axis1=0, axis2=1)

Return specified diagonals. In NumPy 1.9 the returned array is a read-only view instead of a copy as in previous NumPy versions. In a future version the read-only restriction will be removed.

Refer to :func:`numpy.diagonal` for full documentation.

See Also -------- numpy.diagonal : equivalent function

a.dot(b, out=None)

Masked dot product of two arrays. Note that `out` and `strict` are located in different positions than in `ma.dot`. In order to maintain compatibility with the functional version, it is recommended that the optional arguments be treated as keyword only. At some point that may be mandatory.

.. versionadded:: 1.10.0

Parameters ---------- b : masked_array_like Inputs array. out : masked_array, 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 `ma.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. strict : bool, optional Whether masked data are propagated (True) or set to 0 (False) for the computation. Default is False. Propagating the mask means that if a masked value appears in a row or column, the whole row or column is considered masked.

.. versionadded:: 1.10.2

See Also -------- numpy.ma.dot : equivalent function

a.dump(file)

Dump a pickle of the array to the specified file. The array can be read back with pickle.load or numpy.load.

Parameters ---------- file : str or Path A string naming the dump file.

.. versionchanged:: 1.17.0 `pathlib.Path` objects are now accepted.

a.fill(value)

Fill the array with a scalar value.

Parameters ---------- value : scalar All elements of `a` will be assigned this value.

Examples -------- >>> a = np.array(1, 2) >>> a.fill(0) >>> a array(0, 0) >>> a = np.empty(2) >>> a.fill(1) >>> a array(1., 1.)

Return a copy of self, with masked values filled with a given value. **However**, if there are no masked values to fill, self will be returned instead as an ndarray.

Parameters ---------- fill_value : array_like, optional The value to use for invalid entries. Can be scalar or non-scalar. If non-scalar, the resulting ndarray must be broadcastable over input array. Default is None, in which case, the `fill_value` attribute of the array is used instead.

Returns ------- filled_array : ndarray A copy of ``self`` with invalid entries replaced by *fill_value* (be it the function argument or the attribute of ``self``), or ``self`` itself as an ndarray if there are no invalid entries to be replaced.

Notes ----- The result is **not** a MaskedArray!

Examples -------- >>> x = np.ma.array(1,2,3,4,5, mask=0,0,1,0,1, fill_value=-999) >>> x.filled() array( 1, 2, -999, 4, -999) >>> x.filled(fill_value=1000) array( 1, 2, 1000, 4, 1000) >>> type(x.filled()) <class 'numpy.ndarray'>

Subclassing is preserved. This means that if, e.g., the data part of the masked array is a recarray, `filled` returns a recarray:

>>> x = np.array((-1, 2), (-3, 4), dtype='i8,i8').view(np.recarray) >>> m = np.ma.array(x, mask=(True, False), (False, True)) >>> m.filled() rec.array((999999, 2), ( -3, 999999), dtype=('f0', '<i8'), ('f1', '<i8'))

a.flatten(order='C')

Return a copy of the array collapsed into one dimension.

Parameters ---------- order : 'C', 'F', 'A', 'K', optional 'C' means to flatten in row-major (C-style) order. 'F' means to flatten in column-major (Fortran- style) order. 'A' means to flatten in column-major order if `a` is Fortran *contiguous* in memory, row-major order otherwise. 'K' means to flatten `a` in the order the elements occur in memory. The default is 'C'.

Returns ------- y : ndarray A copy of the input array, flattened to one dimension.

See Also -------- ravel : Return a flattened array. flat : A 1-D flat iterator over the array.

Examples -------- >>> a = np.array([1,2], [3,4]) >>> a.flatten() array(1, 2, 3, 4) >>> a.flatten('F') array(1, 3, 2, 4)

The filling value of the masked array is a scalar. When setting, None will set to a default based on the data type.

Examples -------- >>> for dt in np.int32, np.int64, np.float64, np.complex128: ... np.ma.array(0, 1, dtype=dt).get_fill_value() ... 999999 999999 1e+20 (1e+20+0j)

>>> x = np.ma.array(0, 1., fill_value=-np.inf) >>> x.fill_value -inf >>> x.fill_value = np.pi >>> x.fill_value 3.1415926535897931 # may vary

Reset to default:

>>> x.fill_value = None >>> x.fill_value 1e+20

The imaginary part of the masked array.

This property is a view on the imaginary part of this `MaskedArray`.

See Also -------- real

Examples -------- >>> x = np.ma.array(1+1.j, -2j, 3.45+1.6j, mask=False, True, False) >>> x.imag masked_array(data=1.0, --, 1.6, mask=False, True, False, fill_value=1e+20)

The real part of the masked array.

This property is a view on the real part of this `MaskedArray`.

See Also -------- imag

Examples -------- >>> x = np.ma.array(1+1.j, -2j, 3.45+1.6j, mask=False, True, False) >>> x.real masked_array(data=1.0, --, 3.45, mask=False, True, False, fill_value=1e+20)

a.getfield(dtype, offset=0)

Returns a field of the given array as a certain type.

A field is a view of the array data with a given data-type. The values in the view are determined by the given type and the offset into the current array in bytes. The offset needs to be such that the view dtype fits in the array dtype; for example an array of dtype complex128 has 16-byte elements. If taking a view with a 32-bit integer (4 bytes), the offset needs to be between 0 and 12 bytes.

Parameters ---------- dtype : str or dtype The data type of the view. The dtype size of the view can not be larger than that of the array itself. offset : int Number of bytes to skip before beginning the element view.

Examples -------- >>> x = np.diag(1.+1.j*2) >>> x1, 1 = 2 + 4.j >>> x array([1.+1.j, 0.+0.j], [0.+0.j, 2.+4.j]) >>> x.getfield(np.float64) array([1., 0.], [0., 2.])

By choosing an offset of 8 bytes we can select the complex part of the array for our view:

>>> x.getfield(np.float64, offset=8) array([1., 0.], [0., 4.])

Force the mask to hard.

Whether the mask of a masked array is hard or soft is determined by its `hardmask` property. `harden_mask` sets `hardmask` to True.

See Also -------- hardmask

Return the addresses of the data and mask areas.

Parameters ---------- None

Examples -------- >>> x = np.ma.array(1, 2, 3, mask=0, 1, 1) >>> x.ids() (166670640, 166659832) # may vary

If the array has no mask, the address of `nomask` is returned. This address is typically not close to the data in memory:

>>> x = np.ma.array(1, 2, 3) >>> x.ids() (166691080, 3083169284L) # may vary

Return a boolean indicating whether the data is contiguous.

Parameters ---------- None

Examples -------- >>> x = np.ma.array(1, 2, 3) >>> x.iscontiguous() True

`iscontiguous` returns one of the flags of the masked array:

>>> x.flags C_CONTIGUOUS : True F_CONTIGUOUS : True OWNDATA : False WRITEABLE : True ALIGNED : True WRITEBACKIFCOPY : False UPDATEIFCOPY : False

a.item( *args)

Copy an element of an array to a standard Python scalar and return it.

Parameters ---------- \*args : Arguments (variable number and type)

* none: in this case, the method only works for arrays with one element (`a.size == 1`), which element is copied into a standard Python scalar object and returned.

* int_type: this argument is interpreted as a flat index into the array, specifying which element to copy and return.

* tuple of int_types: functions as does a single int_type argument, except that the argument is interpreted as an nd-index into the array.

Returns ------- z : Standard Python scalar object A copy of the specified element of the array as a suitable Python scalar

Notes ----- When the data type of `a` is longdouble or clongdouble, item() returns a scalar array object because there is no available Python scalar that would not lose information. Void arrays return a buffer object for item(), unless fields are defined, in which case a tuple is returned.

`item` is very similar to aargs, except, instead of an array scalar, a standard Python scalar is returned. This can be useful for speeding up access to elements of the array and doing arithmetic on elements of the array using Python's optimized math.

Examples -------- >>> np.random.seed(123) >>> x = np.random.randint(9, size=(3, 3)) >>> x array([2, 2, 6], [1, 3, 6], [1, 0, 1]) >>> x.item(3) 1 >>> x.item(7) 0 >>> x.item((0, 1)) 2 >>> x.item((2, 2)) 1

a.itemset( *args)

Insert scalar into an array (scalar is cast to array's dtype, if possible)

There must be at least 1 argument, and define the last argument as *item*. Then, ``a.itemset( *args)`` is equivalent to but faster than ``aargs = item``. The item should be a scalar value and `args` must select a single item in the array `a`.

Parameters ---------- \*args : Arguments If one argument: a scalar, only used in case `a` is of size 1. If two arguments: the last argument is the value to be set and must be a scalar, the first argument specifies a single array element location. It is either an int or a tuple.

Notes ----- Compared to indexing syntax, `itemset` provides some speed increase for placing a scalar into a particular location in an `ndarray`, if you must do this. However, generally this is discouraged: among other problems, it complicates the appearance of the code. Also, when using `itemset` (and `item`) inside a loop, be sure to assign the methods to a local variable to avoid the attribute look-up at each loop iteration.

Examples -------- >>> np.random.seed(123) >>> x = np.random.randint(9, size=(3, 3)) >>> x array([2, 2, 6], [1, 3, 6], [1, 0, 1]) >>> x.itemset(4, 0) >>> x.itemset((2, 2), 9) >>> x array([2, 2, 6], [1, 0, 6], [1, 0, 9])

Return the maximum along a given axis.

Parameters ---------- axis : None, int, optional Axis along which to operate. By default, ``axis`` is None and the flattened input is used. out : array_like, optional Alternative output array in which to place the result. Must be of the same shape and buffer length as the expected output. fill_value :

ar}, optional
    Value used to fill in the masked values.
    If None, use the output of maximum_fill_value().
keepdims : bool, optional
    If this is set to True, the axes which are reduced are left
    in the result as dimensions with size one. With this option,
    the result will broadcast correctly against the array.

Returns
-------
amax : array_like
    New array holding the result.
    If ``out`` was specified, ``out`` is returned.

See Also
--------
maximum_fill_value
    Returns the maximum filling value for a given datatype.

Returns the average of the array elements along given axis.

Masked entries are ignored, and result elements which are not finite will be masked.

Refer to `numpy.mean` for full documentation.

See Also -------- numpy.ndarray.mean : corresponding function for ndarrays numpy.mean : Equivalent function numpy.ma.average: Weighted average.

Examples -------- >>> a = np.ma.array(1,2,3, mask=False, False, True) >>> a masked_array(data=1, 2, --, mask=False, False, True, fill_value=999999) >>> a.mean() 1.5

Return the minimum along a given axis.

Parameters ---------- axis : None, int, optional Axis along which to operate. By default, ``axis`` is None and the flattened input is used. out : array_like, optional Alternative output array in which to place the result. Must be of the same shape and buffer length as the expected output. fill_value :

ar}, optional
    Value used to fill in the masked values.
    If None, use the output of `minimum_fill_value`.
keepdims : bool, optional
    If this is set to True, the axes which are reduced are left
    in the result as dimensions with size one. With this option,
    the result will broadcast correctly against the array.

Returns
-------
amin : array_like
    New array holding the result.
    If ``out`` was specified, ``out`` is returned.

See Also
--------
minimum_fill_value
    Returns the minimum filling value for a given datatype.

Return the array minimum along the specified axis.

.. deprecated:: 1.13.0 This function is identical to both:

* ``self.min(keepdims=True, axis=axis).squeeze(axis=axis)`` * ``np.ma.minimum.reduce(self, axis=axis)``

Typically though, ``self.min(axis=axis)`` is sufficient.

Parameters ---------- axis : int, optional The axis along which to find the minima. Default is None, in which case the minimum value in the whole array is returned.

Returns ------- min : scalar or MaskedArray If `axis` is None, the result is a scalar. Otherwise, if `axis` is given and the array is at least 2-D, the result is a masked array with dimension one smaller than the array on which `mini` is called.

Examples -------- >>> x = np.ma.array(np.arange(6), mask=0 ,1, 0, 0, 0 ,1).reshape(3, 2) >>> x masked_array( data=[0, --], [2, 3], [4, --], mask=[False, True], [False, False], [False, True], fill_value=999999) >>> x.mini() masked_array(data=0, mask=False, fill_value=999999) >>> x.mini(axis=0) masked_array(data=0, 3, mask=False, False, fill_value=999999) >>> x.mini(axis=1) masked_array(data=0, 2, 4, mask=False, False, False, fill_value=999999)

There is a small difference between `mini` and `min`:

>>> x:,1.mini(axis=0) masked_array(data=3, mask=False, fill_value=999999) >>> x:,1.min(axis=0) 3

arr.newbyteorder(new_order='S')

Return the array with the same data viewed with a different byte order.

Equivalent to::

arr.view(arr.dtype.newbytorder(new_order))

Changes are also made in all fields and sub-arrays of the array data type.

Parameters ---------- new_order : string, optional Byte order to force; a value from the byte order specifications below. `new_order` codes can be any of:

* 'S' - swap dtype from current to opposite endian * '<', 'L' - little endian * '>', 'B' - big endian * '=', 'N' - native order * '|', 'I' - ignore (no change to byte order)

The default value ('S') results in swapping the current byte order. The code does a case-insensitive check on the first letter of `new_order` for the alternatives above. For example, any of 'B' or 'b' or 'biggish' are valid to specify big-endian.

Returns ------- new_arr : array New array object with the dtype reflecting given change to the byte order.

Return the indices of unmasked elements that are not zero.

Returns a tuple of arrays, one for each dimension, containing the indices of the non-zero elements in that dimension. The corresponding non-zero values can be obtained with::

aa.nonzero()

To group the indices by element, rather than dimension, use instead::

np.transpose(a.nonzero())

The result of this is always a 2d array, with a row for each non-zero element.

Parameters ---------- None

Returns ------- tuple_of_arrays : tuple Indices of elements that are non-zero.

See Also -------- numpy.nonzero : Function operating on ndarrays. flatnonzero : Return indices that are non-zero in the flattened version of the input array. numpy.ndarray.nonzero : Equivalent ndarray method. count_nonzero : Counts the number of non-zero elements in the input array.

Examples -------- >>> import numpy.ma as ma >>> x = ma.array(np.eye(3)) >>> x masked_array( data=[1., 0., 0.], [0., 1., 0.], [0., 0., 1.], mask=False, fill_value=1e+20) >>> x.nonzero() (array(0, 1, 2), array(0, 1, 2))

Masked elements are ignored.

>>> x1, 1 = ma.masked >>> x masked_array( data=[1.0, 0.0, 0.0], [0.0, --, 0.0], [0.0, 0.0, 1.0], mask=[False, False, False], [False, True, False], [False, False, False], fill_value=1e+20) >>> x.nonzero() (array(0, 2), array(0, 2))

Indices can also be grouped by element.

>>> np.transpose(x.nonzero()) array([0, 0], [2, 2])

A common use for ``nonzero`` is to find the indices of an array, where a condition is True. Given an array `a`, the condition `a` > 3 is a boolean array and since False is interpreted as 0, ma.nonzero(a > 3) yields the indices of the `a` where the condition is true.

>>> a = ma.array([1,2,3],[4,5,6],[7,8,9]) >>> a > 3 masked_array( data=[False, False, False], [ True, True, True], [ True, True, True], mask=False, fill_value=True) >>> ma.nonzero(a > 3) (array(1, 1, 1, 2, 2, 2), array(0, 1, 2, 0, 1, 2))

The ``nonzero`` method of the condition array can also be called.

>>> (a > 3).nonzero() (array(1, 1, 1, 2, 2, 2), array(0, 1, 2, 0, 1, 2))

a.partition(kth, axis=-1, kind='introselect', order=None)

Rearranges the elements in the array in such a way that the value of the element in kth position is in the position it would be in a sorted array. All elements smaller than the kth element are moved before this element and all equal or greater are moved behind it. The ordering of the elements in the two partitions is undefined.

.. versionadded:: 1.8.0

Parameters ---------- kth : int or sequence of ints Element index to partition by. The kth element value will be in its final sorted position and all smaller elements will be moved before it and all equal or greater elements behind it. The order of all elements in the partitions is undefined. If provided with a sequence of kth it will partition all elements indexed by kth of them into their sorted position at once. axis : int, optional Axis along which to sort. Default is -1, which means sort along the last axis. kind : 'introselect', optional Selection algorithm. Default is 'introselect'. order : str or list of str, optional When `a` is an array with fields defined, this argument specifies which fields to compare first, second, etc. A single field can be specified as a string, and not all fields need to be specified, but unspecified fields will still be used, in the order in which they come up in the dtype, to break ties.

See Also -------- numpy.partition : Return a parititioned copy of an array. argpartition : Indirect partition. sort : Full sort.

Notes ----- See ``np.partition`` for notes on the different algorithms.

Examples -------- >>> a = np.array(3, 4, 2, 1) >>> a.partition(3) >>> a array(2, 1, 3, 4)

>>> a.partition((1, 3)) >>> a array(1, 2, 3, 4)

Return the product of the array elements over the given axis.

Masked elements are set to 1 internally for computation.

Refer to `numpy.prod` for full documentation.

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

See Also -------- numpy.ndarray.prod : corresponding function for ndarrays numpy.prod : equivalent function

Return (maximum - minimum) along the given dimension (i.e. peak-to-peak value).

Parameters ---------- axis : None, int, optional Axis along which to find the peaks. If None (default) the flattened array is used. out : None, array_like, optional Alternative output array in which to place the result. It must have the same shape and buffer length as the expected output but the type will be cast if necessary. fill_value :

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

Returns
-------
ptp : ndarray.
    A new array holding the result, unless ``out`` was
    specified, in which case a reference to ``out`` is returned.

Set storage-indexed locations to corresponding values.

Sets self._data.flatn = valuesn for each n in indices. If `values` is shorter than `indices` then it will repeat. If `values` has some masked values, the initial mask is updated in consequence, else the corresponding values are unmasked.

Parameters ---------- indices : 1-D array_like Target indices, interpreted as integers. values : array_like Values to place in self._data copy at target indices. 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.

Notes ----- `values` can be a scalar or length 1 array.

Examples -------- >>> x = np.ma.array([1,2,3],[4,5,6],[7,8,9], mask=0 + 1,0*4) >>> x masked_array( data=[1, --, 3], [--, 5, --], [7, --, 9], mask=[False, True, False], [ True, False, True], [False, True, False], fill_value=999999) >>> x.put(0,4,8,10,20,30) >>> x masked_array( data=[10, --, 3], [--, 20, --], [7, --, 30], mask=[False, True, False], [ True, False, True], [False, True, False], fill_value=999999)

>>> x.put(4,999) >>> x masked_array( data=[10, --, 3], [--, 999, --], [7, --, 30], mask=[False, True, False], [ True, False, True], [False, True, False], fill_value=999999)

Returns a 1D version of self, as a view.

Parameters ---------- order : 'C', 'F', 'A', 'K', optional The elements of `a` are read using this index order. 'C' means to index the elements in C-like order, with the last axis index changing fastest, back to the first axis index changing slowest. 'F' means to index the elements in Fortran-like index order, with the first index changing fastest, and the last index changing slowest. Note that the 'C' and 'F' options take no account of the memory layout of the underlying array, and only refer to the order of axis indexing. 'A' means to read the elements in Fortran-like index order if `m` is Fortran *contiguous* in memory, C-like order otherwise. 'K' means to read the elements in the order they occur in memory, except for reversing the data when strides are negative. By default, 'C' index order is used.

Returns ------- MaskedArray Output view is of shape ``(self.size,)`` (or ``(np.ma.product(self.shape),)``).

Examples -------- >>> x = np.ma.array([1,2,3],[4,5,6],[7,8,9], mask=0 + 1,0*4) >>> x masked_array( data=[1, --, 3], [--, 5, --], [7, --, 9], mask=[False, True, False], [ True, False, True], [False, True, False], fill_value=999999) >>> x.ravel() masked_array(data=1, --, 3, --, 5, --, 7, --, 9, mask=False, True, False, True, False, True, False, True, False, fill_value=999999)

a.repeat(repeats, axis=None)

Repeat elements of an array.

Refer to `numpy.repeat` for full documentation.

See Also -------- numpy.repeat : equivalent function

Give a new shape to the array without changing its data.

Returns a masked array containing the same data, but with a new shape. The result is a view on the original array; if this is not possible, a ValueError is raised.

Parameters ---------- shape : int or tuple of ints The new shape should be compatible with the original shape. If an integer is supplied, then the result will be a 1-D array of that length. order : 'C', 'F', optional Determines whether the array data should be viewed as in C (row-major) or FORTRAN (column-major) order.

Returns ------- reshaped_array : array A new view on the array.

See Also -------- reshape : Equivalent function in the masked array module. numpy.ndarray.reshape : Equivalent method on ndarray object. numpy.reshape : Equivalent function in the NumPy module.

Notes ----- The reshaping operation cannot guarantee that a copy will not be made, to modify the shape in place, use ``a.shape = s``

Examples -------- >>> x = np.ma.array([1,2],[3,4], mask=1,0,0,1) >>> x masked_array( data=[--, 2], [3, --], mask=[ True, False], [False, True], fill_value=999999) >>> x = x.reshape((4,1)) >>> x masked_array( data=[--], [2], [3], [--], mask=[ True], [False], [False], [ True], fill_value=999999)

.. warning::

This method does nothing, except raise a ValueError exception. A masked array does not own its data and therefore cannot safely be resized in place. Use the `numpy.ma.resize` function instead.

This method is difficult to implement safely and may be deprecated in future releases of NumPy.

Return each element rounded to the given number of decimals.

Refer to `numpy.around` for full documentation.

See Also -------- numpy.ndarray.around : corresponding function for ndarrays numpy.around : equivalent function

a.searchsorted(v, side='left', sorter=None)

Find indices where elements of v should be inserted in a to maintain order.

For full documentation, see `numpy.searchsorted`

See Also -------- numpy.searchsorted : equivalent function

The filling value of the masked array is a scalar. When setting, None will set to a default based on the data type.

Examples -------- >>> for dt in np.int32, np.int64, np.float64, np.complex128: ... np.ma.array(0, 1, dtype=dt).get_fill_value() ... 999999 999999 1e+20 (1e+20+0j)

>>> x = np.ma.array(0, 1., fill_value=-np.inf) >>> x.fill_value -inf >>> x.fill_value = np.pi >>> x.fill_value 3.1415926535897931 # may vary

Reset to default:

>>> x.fill_value = None >>> x.fill_value 1e+20

a.setfield(val, dtype, offset=0)

Put a value into a specified place in a field defined by a data-type.

Place `val` into `a`'s field defined by `dtype` and beginning `offset` bytes into the field.

Parameters ---------- val : object Value to be placed in field. dtype : dtype object Data-type of the field in which to place `val`. offset : int, optional The number of bytes into the field at which to place `val`.

Returns ------- None

See Also -------- getfield

Examples -------- >>> x = np.eye(3) >>> x.getfield(np.float64) array([1., 0., 0.], [0., 1., 0.], [0., 0., 1.]) >>> x.setfield(3, np.int32) >>> x.getfield(np.int32) array([3, 3, 3], [3, 3, 3], [3, 3, 3], dtype=int32) >>> x array([1.0e+000, 1.5e-323, 1.5e-323], [1.5e-323, 1.0e+000, 1.5e-323], [1.5e-323, 1.5e-323, 1.0e+000]) >>> x.setfield(np.eye(3), np.int32) >>> x array([1., 0., 0.], [0., 1., 0.], [0., 0., 1.])

a.setflags(write=None, align=None, uic=None)

Set array flags WRITEABLE, ALIGNED, (WRITEBACKIFCOPY and UPDATEIFCOPY), respectively.

These Boolean-valued flags affect how numpy interprets the memory area used by `a` (see Notes below). The ALIGNED flag can only be set to True if the data is actually aligned according to the type. The WRITEBACKIFCOPY and (deprecated) UPDATEIFCOPY flags can never be set to True. The flag WRITEABLE can only be set to True if the array owns its own memory, or the ultimate owner of the memory exposes a writeable buffer interface, or is a string. (The exception for string is made so that unpickling can be done without copying memory.)

Parameters ---------- write : bool, optional Describes whether or not `a` can be written to. align : bool, optional Describes whether or not `a` is aligned properly for its type. uic : bool, optional Describes whether or not `a` is a copy of another 'base' array.

Notes ----- Array flags provide information about how the memory area used for the array is to be interpreted. There are 7 Boolean flags in use, only four of which can be changed by the user: WRITEBACKIFCOPY, UPDATEIFCOPY, WRITEABLE, and ALIGNED.

WRITEABLE (W) the data area can be written to;

ALIGNED (A) the data and strides are aligned appropriately for the hardware (as determined by the compiler);

UPDATEIFCOPY (U) (deprecated), replaced by WRITEBACKIFCOPY;

WRITEBACKIFCOPY (X) this array is a copy of some other array (referenced by .base). When the C-API function PyArray_ResolveWritebackIfCopy is called, the base array will be updated with the contents of this array.

All flags can be accessed using the single (upper case) letter as well as the full name.

Examples -------- >>> y = np.array([3, 1, 7], ... [2, 0, 0], ... [8, 5, 9]) >>> y array([3, 1, 7], [2, 0, 0], [8, 5, 9]) >>> y.flags C_CONTIGUOUS : True F_CONTIGUOUS : False OWNDATA : True WRITEABLE : True ALIGNED : True WRITEBACKIFCOPY : False UPDATEIFCOPY : False >>> y.setflags(write=0, align=0) >>> y.flags C_CONTIGUOUS : True F_CONTIGUOUS : False OWNDATA : True WRITEABLE : False ALIGNED : False WRITEBACKIFCOPY : False UPDATEIFCOPY : False >>> y.setflags(uic=1) Traceback (most recent call last): File '<stdin>', line 1, in <module> ValueError: cannot set WRITEBACKIFCOPY flag to True

Reduce a mask to nomask when possible.

Parameters ---------- None

Returns ------- None

Examples -------- >>> x = np.ma.array([1,2 ], [3, 4], mask=0*4) >>> x.mask array([False, False], [False, False]) >>> x.shrink_mask() masked_array( data=[1, 2], [3, 4], mask=False, fill_value=999999) >>> x.mask False

Force the mask to soft.

Whether the mask of a masked array is hard or soft is determined by its `hardmask` property. `soften_mask` sets `hardmask` to False.

See Also -------- hardmask

Sort the array, in-place

Parameters ---------- a : array_like Array to be sorted. axis : int, optional Axis along which to sort. If None, the array is flattened before sorting. The default is -1, which sorts along the last axis. kind : 'quicksort', 'mergesort', 'heapsort', 'stable', optional The sorting algorithm used. order : list, optional When `a` is a structured array, this argument specifies which fields to compare first, second, and so on. This list does not need to include all of the fields. 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 sorting at the same extremes of the datatype, the ordering of these values and the masked values is undefined. fill_value :

ar}, optional
    Value used internally for the masked values.
    If ``fill_value`` is not None, it supersedes ``endwith``.

Returns
-------
sorted_array : ndarray
    Array of the same type and shape as `a`.

See Also
--------
numpy.ndarray.sort : Method to sort an array in-place.
argsort : Indirect sort.
lexsort : Indirect stable sort on multiple keys.
searchsorted : Find elements in a sorted array.

Notes
-----
See ``sort`` for notes on the different sorting algorithms.

Examples
--------
>>> a = np.ma.array([1, 2, 5, 4, 3],mask=[0, 1, 0, 1, 0])
>>> # Default
>>> a.sort()
>>> a
masked_array(data=[1, 3, 5, --, --],
             mask=[False, False, False,  True,  True],
       fill_value=999999)

>>> a = np.ma.array([1, 2, 5, 4, 3],mask=[0, 1, 0, 1, 0])
>>> # Put missing values in the front
>>> a.sort(endwith=False)
>>> a
masked_array(data=[--, --, 1, 3, 5],
             mask=[ True,  True, False, False, False],
       fill_value=999999)

>>> a = np.ma.array([1, 2, 5, 4, 3],mask=[0, 1, 0, 1, 0])
>>> # fill_value takes over endwith
>>> a.sort(endwith=False, fill_value=3)
>>> a
masked_array(data=[1, --, --, 3, 5],
             mask=[False,  True,  True, False, False],
       fill_value=999999)

a.squeeze(axis=None)

Remove single-dimensional entries from the shape of `a`.

Refer to `numpy.squeeze` for full documentation.

See Also -------- numpy.squeeze : equivalent function

Returns the standard deviation of the array elements along given axis.

Masked entries are ignored.

Refer to `numpy.std` for full documentation.

See Also -------- numpy.ndarray.std : corresponding function for ndarrays numpy.std : Equivalent function

Return the sum of the array elements over the given axis.

Masked elements are set to 0 internally.

Refer to `numpy.sum` for full documentation.

See Also -------- numpy.ndarray.sum : corresponding function for ndarrays numpy.sum : equivalent function

Examples -------- >>> x = np.ma.array([1,2,3],[4,5,6],[7,8,9], mask=0 + 1,0*4) >>> x masked_array( data=[1, --, 3], [--, 5, --], [7, --, 9], mask=[False, True, False], [ True, False, True], [False, True, False], fill_value=999999) >>> x.sum() 25 >>> x.sum(axis=1) masked_array(data=4, 5, 16, mask=False, False, False, fill_value=999999) >>> x.sum(axis=0) masked_array(data=8, 5, 12, mask=False, False, False, fill_value=999999) >>> print(type(x.sum(axis=0, dtype=np.int64)0)) <class 'numpy.int64'>

a.swapaxes(axis1, axis2)

Return a view of the array with `axis1` and `axis2` interchanged.

Refer to `numpy.swapaxes` for full documentation.

See Also -------- numpy.swapaxes : equivalent function

Return the array data as a string containing the raw bytes in the array.

The array is filled with a fill value before the string conversion.

.. versionadded:: 1.9.0

Parameters ---------- fill_value : scalar, optional Value used to fill in the masked values. Default is None, in which case `MaskedArray.fill_value` is used. order : 'C','F','A', optional Order of the data item in the copy. Default is 'C'.

• 'C' -- C order (row major).
• 'F' -- Fortran order (column major).
• 'A' -- Any, current order of array.
• None -- Same as 'A'.

See Also -------- numpy.ndarray.tobytes tolist, tofile

Notes ----- As for `ndarray.tobytes`, information about the shape, dtype, etc., but also about `fill_value`, will be lost.

Examples -------- >>> x = np.ma.array(np.array([1, 2], [3, 4]), mask=[0, 1], [1, 0]) >>> x.tobytes() b'\x01\x00\x00\x00\x00\x00\x00\x00?B\x0f\x00\x00\x00\x00\x00?B\x0f\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00'

Save a masked array to a file in binary format.

.. warning:: This function is not implemented yet.

Raises ------ NotImplementedError When `tofile` is called.

Transforms a masked array into a flexible-type array.

The flexible type array that is returned will have two fields:

* the ``_data`` field stores the ``_data`` part of the array. * the ``_mask`` field stores the ``_mask`` part of the array.

Parameters ---------- None

Returns ------- record : ndarray A new flexible-type `ndarray` with two fields: the first element containing a value, the second element containing the corresponding mask boolean. The returned record shape matches self.shape.

Notes ----- A side-effect of transforming a masked array into a flexible `ndarray` is that meta information (``fill_value``, ...) will be lost.

Examples -------- >>> x = np.ma.array([1,2,3],[4,5,6],[7,8,9], mask=0 + 1,0*4) >>> x masked_array( data=[1, --, 3], [--, 5, --], [7, --, 9], mask=[False, True, False], [ True, False, True], [False, True, False], fill_value=999999) >>> x.toflex() array([(1, False), (2, True), (3, False)], [(4, True), (5, False), (6, True)], [(7, False), (8, True), (9, False)], dtype=('_data', '<i8'), ('_mask', '?'))

Return the data portion of the masked array as a hierarchical Python list.

Data items are converted to the nearest compatible Python type. Masked values are converted to `fill_value`. If `fill_value` is None, the corresponding entries in the output list will be ``None``.

Parameters ---------- fill_value : scalar, optional The value to use for invalid entries. Default is None.

Returns ------- result : list The Python list representation of the masked array.

Examples -------- >>> x = np.ma.array([1,2,3], [4,5,6], [7,8,9], mask=0 + 1,0*4) >>> x.tolist() [1, None, 3], [None, 5, None], [7, None, 9] >>> x.tolist(-999) [1, -999, 3], [-999, 5, -999], [7, -999, 9]

This function is a compatibility alias for tobytes. Despite its name it returns bytes not strings.

a.trace(offset=0, axis1=0, axis2=1, dtype=None, out=None)

Return the sum along diagonals of the array.

Refer to `numpy.trace` for full documentation.

See Also -------- numpy.trace : equivalent function

a.transpose( *axes)

Returns a view of the array with axes transposed.

For a 1-D array this has no effect, as a transposed vector is simply the same vector. To convert a 1-D array into a 2D column vector, an additional dimension must be added. `np.atleast2d(a).T` achieves this, as does `a:, np.newaxis`. For a 2-D array, this is a standard matrix transpose. For an n-D array, if axes are given, their order indicates how the axes are permuted (see Examples). If axes are not provided and ``a.shape = (i0, i1, ... in-2, in-1)``, then ``a.transpose().shape = (in-1, in-2, ... i1, i0)``.

Parameters ---------- axes : None, tuple of ints, or `n` ints

* None or no argument: reverses the order of the axes.

* tuple of ints: `i` in the `j`-th place in the tuple means `a`'s `i`-th axis becomes `a.transpose()`'s `j`-th axis.

* `n` ints: same as an n-tuple of the same ints (this form is intended simply as a 'convenience' alternative to the tuple form)

Returns ------- out : ndarray View of `a`, with axes suitably permuted.

See Also -------- ndarray.T : Array property returning the array transposed. ndarray.reshape : Give a new shape to an array without changing its data.

Examples -------- >>> a = np.array([1, 2], [3, 4]) >>> a array([1, 2], [3, 4]) >>> a.transpose() array([1, 3], [2, 4]) >>> a.transpose((1, 0)) array([1, 3], [2, 4]) >>> a.transpose(1, 0) array([1, 3], [2, 4])

Copy the mask and set the sharedmask flag to False.

Whether the mask is shared between masked arrays can be seen from the `sharedmask` property. `unshare_mask` ensures the mask is not shared. A copy of the mask is only made if it was shared.

See Also -------- sharedmask

Compute the variance along the specified axis.

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

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

.. versionadded:: 1.7.0

If this is a tuple of ints, a variance is performed over multiple axes, instead of a single axis or all the axes as before. dtype : data-type, optional Type to use in computing the variance. For arrays of integer type the default is `float64`; for arrays of float types it is the same as the array type. out : ndarray, optional Alternate output array in which to place the result. It must have the same shape as the expected output, but the type is cast if necessary. ddof : int, optional 'Delta Degrees of Freedom': the divisor used in the calculation is ``N - ddof``, where ``N`` represents the number of elements. By default `ddof` is zero. keepdims : bool, optional If this is set to True, the axes which are reduced are left in the result as dimensions with size one. With this option, the result will broadcast correctly against the input array.

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

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

See Also -------- std, mean, nanmean, nanstd, nanvar ufuncs-output-type

Notes ----- The variance is the average of the squared deviations from the mean, i.e., ``var = mean(abs(x - x.mean())**2)``.

The mean is normally calculated as ``x.sum() / N``, where ``N = len(x)``. If, however, `ddof` is specified, the divisor ``N - ddof`` is used instead. In standard statistical practice, ``ddof=1`` provides an unbiased estimator of the variance of a hypothetical infinite population. ``ddof=0`` provides a maximum likelihood estimate of the variance for normally distributed variables.

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

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

Examples -------- >>> a = np.array([1, 2], [3, 4]) >>> np.var(a) 1.25 >>> np.var(a, axis=0) array(1., 1.) >>> np.var(a, axis=1) array(0.25, 0.25)

In single precision, var() can be inaccurate:

>>> a = np.zeros((2, 512*512), dtype=np.float32) >>> a0, : = 1.0 >>> a1, : = 0.1 >>> np.var(a) 0.20250003

Computing the variance in float64 is more accurate:

>>> np.var(a, dtype=np.float64) 0.20249999932944759 # may vary >>> ((1-0.55)**2 + (0.1-0.55)**2)/2 0.2025

Return a view of the MaskedArray data.

Parameters ---------- dtype : data-type or ndarray sub-class, optional Data-type descriptor of the returned view, e.g., float32 or int16. The default, None, results in the view having the same data-type as `a`. As with ``ndarray.view``, dtype can also be specified as an ndarray sub-class, which then specifies the type of the returned object (this is equivalent to setting the ``type`` parameter). type : Python type, optional Type of the returned view, either ndarray or a subclass. The default None results in type preservation. fill_value : scalar, optional The value to use for invalid entries (None by default). If None, then this argument is inferred from the passed `dtype`, or in its absence the original array, as discussed in the notes below.

See Also -------- numpy.ndarray.view : Equivalent method on ndarray object.

Notes -----

``a.view()`` is used two different ways:

``a.view(some_dtype)`` or ``a.view(dtype=some_dtype)`` constructs a view of the array's memory with a different data-type. This can cause a reinterpretation of the bytes of memory.

``a.view(ndarray_subclass)`` or ``a.view(type=ndarray_subclass)`` just returns an instance of `ndarray_subclass` that looks at the same array (same shape, dtype, etc.) This does not cause a reinterpretation of the memory.

If `fill_value` is not specified, but `dtype` is specified (and is not an ndarray sub-class), the `fill_value` of the MaskedArray will be reset. If neither `fill_value` nor `dtype` are specified (or if `dtype` is an ndarray sub-class), then the fill value is preserved. Finally, if `fill_value` is specified, but `dtype` is not, the fill value is set to the specified value.

For ``a.view(some_dtype)``, if ``some_dtype`` has a different number of bytes per entry than the previous dtype (for example, converting a regular array to a structured array), then the behavior of the view cannot be predicted just from the superficial appearance of ``a`` (shown by ``print(a)``). It also depends on exactly how ``a`` is stored in memory. Therefore if ``a`` is C-ordered versus fortran-ordered, versus defined as a slice or transpose, etc., the view may give different results.

Print the object to a human-readable representation.

Print the object to a human-readable representation.

Pretty-print the object to a formatter.