Masked array operations#

Constants#

ma.MaskType

alias of bool

Creation#

From existing data#

`ma.masked_array`	alias of `MaskedArray`
`ma.array`(data[, dtype, copy, order, mask, ...])	An array class with possibly masked values.
`ma.copy`(self, args, *params) a.copy(order=)	Return a copy of the array.
`ma.frombuffer`(buffer[, dtype, count, ...])	Interpret a buffer as a 1-dimensional array.
`ma.fromfunction`(function, shape, **dtype)	Construct an array by executing a function over each coordinate.
`ma.MaskedArray.copy`([order])	Return a copy of the array.
`ma.diagflat`	Create a two-dimensional array with the flattened input as a diagonal.

Ones and zeros#

`ma.empty`(shape[, dtype, order, device, like])	Return a new array of given shape and type, without initializing entries.
`ma.empty_like`(prototype[, dtype, order, ...])	Return a new array with the same shape and type as a given array.
`ma.masked_all`(shape[, dtype])	Empty masked array with all elements masked.
`ma.masked_all_like`(arr)	Empty masked array with the properties of an existing array.
`ma.ones`(shape[, dtype, order])	Return a new array of given shape and type, filled with ones.
`ma.ones_like`	Return an array of ones with the same shape and type as a given array.
`ma.zeros`(shape[, dtype, order, like])	Return a new array of given shape and type, filled with zeros.
`ma.zeros_like`	Return an array of zeros with the same shape and type as a given array.

Inspecting the array#

`ma.all`(self[, axis, out, keepdims])	Returns True if all elements evaluate to True.
`ma.any`(self[, axis, out, keepdims])	Returns True if any of the elements of a evaluate to True.
`ma.count`(self[, axis, keepdims])	Count the non-masked elements of the array along the given axis.
`ma.count_masked`(arr[, axis])	Count the number of masked elements along the given axis.
`ma.getmask`(a)	Return the mask of a masked array, or nomask.
`ma.getmaskarray`(arr)	Return the mask of a masked array, or full boolean array of False.
`ma.getdata`(a[, subok])	Return the data of a masked array as an ndarray.
`ma.nonzero`(self)	Return the indices of unmasked elements that are not zero.
`ma.shape`(obj)	Return the shape of an array.
`ma.size`(obj[, axis])	Return the number of elements along a given axis.
`ma.is_masked`(x)	Determine whether input has masked values.
`ma.is_mask`(m)	Return True if m is a valid, standard mask.
`ma.isMaskedArray`(x)	Test whether input is an instance of MaskedArray.
`ma.isMA`(x)	Test whether input is an instance of MaskedArray.
`ma.isarray`(x)	Test whether input is an instance of MaskedArray.
`ma.isin`(element, test_elements[, ...])	Calculates element in test_elements, broadcasting over element only.
`ma.in1d`(ar1, ar2[, assume_unique, invert])	Test whether each element of an array is also present in a second array.
`ma.unique`(ar1[, return_index, return_inverse])	Finds the unique elements of an array.
`ma.MaskedArray.all`([axis, out, keepdims])	Returns True if all elements evaluate to True.
`ma.MaskedArray.any`([axis, out, keepdims])	Returns True if any of the elements of a evaluate to True.
`ma.MaskedArray.count`([axis, keepdims])	Count the non-masked elements of the array along the given axis.
`ma.MaskedArray.nonzero`()	Return the indices of unmasked elements that are not zero.
`ma.shape`(obj)	Return the shape of an array.
`ma.size`(obj[, axis])	Return the number of elements along a given axis.

`ma.MaskedArray.data`	Returns the underlying data, as a view of the masked array.
`ma.MaskedArray.mask`	Current mask.
`ma.MaskedArray.recordmask`	Get or set the mask of the array if it has no named fields.

Manipulating a MaskedArray#

Changing the shape#

`ma.ravel`(self[, order])	Returns a 1D version of self, as a view.
`ma.reshape`(a, new_shape[, order])	Returns an array containing the same data with a new shape.
`ma.resize`(x, new_shape)	Return a new masked array with the specified size and shape.
`ma.MaskedArray.flatten`([order])	Return a copy of the array collapsed into one dimension.
`ma.MaskedArray.ravel`([order])	Returns a 1D version of self, as a view.
`ma.MaskedArray.reshape`(s, *kwargs)	Give a new shape to the array without changing its data.
`ma.MaskedArray.resize`(newshape[, refcheck, ...])

Modifying axes#

`ma.swapaxes`(self, *args, ...)	Return a view of the array with axis1 and axis2 interchanged.
`ma.transpose`(a[, axes])	Permute the dimensions of an array.
`ma.MaskedArray.swapaxes`(axis1, axis2)	Return a view of the array with axis1 and axis2 interchanged.
`ma.MaskedArray.transpose`(*axes)	Returns a view of the array with axes transposed.

Changing the number of dimensions#

`ma.atleast_1d`	Convert inputs to arrays with at least one dimension.
`ma.atleast_2d`	View inputs as arrays with at least two dimensions.
`ma.atleast_3d`	View inputs as arrays with at least three dimensions.
`ma.expand_dims`(a, axis)	Expand the shape of an array.
`ma.squeeze`	Remove axes of length one from a.
`ma.MaskedArray.squeeze`([axis])	Remove axes of length one from a.
`ma.stack`	Join a sequence of arrays along a new axis.
`ma.column_stack`	Stack 1-D arrays as columns into a 2-D array.
`ma.concatenate`(arrays[, axis])	Concatenate a sequence of arrays along the given axis.
`ma.dstack`	Stack arrays in sequence depth wise (along third axis).
`ma.hstack`	Stack arrays in sequence horizontally (column wise).
`ma.hsplit`	Split an array into multiple sub-arrays horizontally (column-wise).
`ma.mr_`	Translate slice objects to concatenation along the first axis.
`ma.vstack`	Stack arrays in sequence vertically (row wise).

Joining arrays#

`ma.concatenate`(arrays[, axis])	Concatenate a sequence of arrays along the given axis.
`ma.stack`	Join a sequence of arrays along a new axis.
`ma.vstack`	Stack arrays in sequence vertically (row wise).
`ma.hstack`	Stack arrays in sequence horizontally (column wise).
`ma.dstack`	Stack arrays in sequence depth wise (along third axis).
`ma.column_stack`	Stack 1-D arrays as columns into a 2-D array.
`ma.append`(a, b[, axis])	Append values to the end of an array.

Operations on masks#

Creating a mask#

`ma.make_mask`(m[, copy, shrink, dtype])	Create a boolean mask from an array.
`ma.make_mask_none`(newshape[, dtype])	Return a boolean mask of the given shape, filled with False.
`ma.mask_or`(m1, m2[, copy, shrink])	Combine two masks with the `logical_or` operator.
`ma.make_mask_descr`(ndtype)	Construct a dtype description list from a given dtype.

Accessing a mask#

`ma.getmask`(a)	Return the mask of a masked array, or nomask.
`ma.getmaskarray`(arr)	Return the mask of a masked array, or full boolean array of False.
`ma.masked_array.mask`	Current mask.

Finding masked data#

`ma.ndenumerate`(a[, compressed])	Multidimensional index iterator.
`ma.flatnotmasked_contiguous`(a)	Find contiguous unmasked data in a masked array.
`ma.flatnotmasked_edges`(a)	Find the indices of the first and last unmasked values.
`ma.notmasked_contiguous`(a[, axis])	Find contiguous unmasked data in a masked array along the given axis.
`ma.notmasked_edges`(a[, axis])	Find the indices of the first and last unmasked values along an axis.
`ma.clump_masked`(a)	Returns a list of slices corresponding to the masked clumps of a 1-D array.
`ma.clump_unmasked`(a)	Return list of slices corresponding to the unmasked clumps of a 1-D array.

Modifying a mask#

`ma.mask_cols`(a[, axis])	Mask columns of a 2D array that contain masked values.
`ma.mask_or`(m1, m2[, copy, shrink])	Combine two masks with the `logical_or` operator.
`ma.mask_rowcols`(a[, axis])	Mask rows and/or columns of a 2D array that contain masked values.
`ma.mask_rows`(a[, axis])	Mask rows of a 2D array that contain masked values.
`ma.harden_mask`(self)	Force the mask to hard, preventing unmasking by assignment.
`ma.soften_mask`(self)	Force the mask to soft (default), allowing unmasking by assignment.
`ma.MaskedArray.harden_mask`()	Force the mask to hard, preventing unmasking by assignment.
`ma.MaskedArray.soften_mask`()	Force the mask to soft (default), allowing unmasking by assignment.
`ma.MaskedArray.shrink_mask`()	Reduce a mask to nomask when possible.
`ma.MaskedArray.unshare_mask`()	Copy the mask and set the sharedmask flag to `False`.

Conversion operations#

> to a masked array#

`ma.asarray`(a[, dtype, order])	Convert the input to a masked array of the given data-type.
`ma.asanyarray`(a[, dtype])	Convert the input to a masked array, conserving subclasses.
`ma.fix_invalid`(a[, mask, copy, fill_value])	Return input with invalid data masked and replaced by a fill value.
`ma.masked_equal`(x, value[, copy])	Mask an array where equal to a given value.
`ma.masked_greater`(x, value[, copy])	Mask an array where greater than a given value.
`ma.masked_greater_equal`(x, value[, copy])	Mask an array where greater than or equal to a given value.
`ma.masked_inside`(x, v1, v2[, copy])	Mask an array inside a given interval.
`ma.masked_invalid`(a[, copy])	Mask an array where invalid values occur (NaNs or infs).
`ma.masked_less`(x, value[, copy])	Mask an array where less than a given value.
`ma.masked_less_equal`(x, value[, copy])	Mask an array where less than or equal to a given value.
`ma.masked_not_equal`(x, value[, copy])	Mask an array where not equal to a given value.
`ma.masked_object`(x, value[, copy, shrink])	Mask the array x where the data are exactly equal to value.
`ma.masked_outside`(x, v1, v2[, copy])	Mask an array outside a given interval.
`ma.masked_values`(x, value[, rtol, atol, ...])	Mask using floating point equality.
`ma.masked_where`(condition, a[, copy])	Mask an array where a condition is met.

> to a ndarray#

`ma.compress_cols`(a)	Suppress whole columns of a 2-D array that contain masked values.
`ma.compress_rowcols`(x[, axis])	Suppress the rows and/or columns of a 2-D array that contain masked values.
`ma.compress_rows`(a)	Suppress whole rows of a 2-D array that contain masked values.
`ma.compressed`(x)	Return all the non-masked data as a 1-D array.
`ma.filled`(a[, fill_value])	Return input as an `ndarray`, with masked values replaced by fill_value.
`ma.MaskedArray.compressed`()	Return all the non-masked data as a 1-D array.
`ma.MaskedArray.filled`([fill_value])	Return a copy of self, with masked values filled with a given value.

> to another object#

`ma.MaskedArray.tofile`(fid[, sep, format])	Save a masked array to a file in binary format.
`ma.MaskedArray.tolist`([fill_value])	Return the data portion of the masked array as a hierarchical Python list.
`ma.MaskedArray.torecords`()	Transforms a masked array into a flexible-type array.
`ma.MaskedArray.tobytes`([fill_value, order])	Return the array data as a string containing the raw bytes in the array.

Filling a masked array#

`ma.common_fill_value`(a, b)	Return the common filling value of two masked arrays, if any.
`ma.default_fill_value`(obj)	Return the default fill value for the argument object.
`ma.maximum_fill_value`(obj)	Return the minimum value that can be represented by the dtype of an object.
`ma.minimum_fill_value`(obj)	Return the maximum value that can be represented by the dtype of an object.
`ma.set_fill_value`(a, fill_value)	Set the filling value of a, if a is a masked array.
`ma.MaskedArray.get_fill_value`()	The filling value of the masked array is a scalar.
`ma.MaskedArray.set_fill_value`([value])

ma.MaskedArray.fill_value

The filling value of the masked array is a scalar.

Masked arrays arithmetic#

Arithmetic#

`ma.anom`(self[, axis, dtype])	Compute the anomalies (deviations from the arithmetic mean) along the given axis.
`ma.anomalies`(self[, axis, dtype])	Compute the anomalies (deviations from the arithmetic mean) along the given axis.
`ma.average`(a[, axis, weights, returned, ...])	Return the weighted average of array over the given axis.
`ma.conjugate`(x, /[, out, where, casting, ...])	Return the complex conjugate, element-wise.
`ma.corrcoef`(x[, y, rowvar, bias, ...])	Return Pearson product-moment correlation coefficients.
`ma.cov`(x[, y, rowvar, bias, allow_masked, ddof])	Estimate the covariance matrix.
`ma.cumsum`(self[, axis, dtype, out])	Return the cumulative sum of the array elements over the given axis.
`ma.cumprod`(self[, axis, dtype, out])	Return the cumulative product of the array elements over the given axis.
`ma.mean`(self[, axis, dtype, out, keepdims])	Returns the average of the array elements along given axis.
`ma.median`(a[, axis, out, overwrite_input, ...])	Compute the median along the specified axis.
`ma.power`(a, b[, third])	Returns element-wise base array raised to power from second array.
`ma.prod`(self[, axis, dtype, out, keepdims])	Return the product of the array elements over the given axis.
`ma.std`(self[, axis, dtype, out, ddof, ...])	Returns the standard deviation of the array elements along given axis.
`ma.sum`(self[, axis, dtype, out, keepdims])	Return the sum of the array elements over the given axis.
`ma.var`(self[, axis, dtype, out, ddof, ...])	Compute the variance along the specified axis.
`ma.MaskedArray.anom`([axis, dtype])	Compute the anomalies (deviations from the arithmetic mean) along the given axis.
`ma.MaskedArray.cumprod`([axis, dtype, out])	Return the cumulative product of the array elements over the given axis.
`ma.MaskedArray.cumsum`([axis, dtype, out])	Return the cumulative sum of the array elements over the given axis.
`ma.MaskedArray.mean`([axis, dtype, out, keepdims])	Returns the average of the array elements along given axis.
`ma.MaskedArray.prod`([axis, dtype, out, keepdims])	Return the product of the array elements over the given axis.
`ma.MaskedArray.std`([axis, dtype, out, ddof, ...])	Returns the standard deviation of the array elements along given axis.
`ma.MaskedArray.sum`([axis, dtype, out, keepdims])	Return the sum of the array elements over the given axis.
`ma.MaskedArray.var`([axis, dtype, out, ddof, ...])	Compute the variance along the specified axis.

Minimum/maximum#

`ma.argmax`(self[, axis, fill_value, out])	Returns array of indices of the maximum values along the given axis.
`ma.argmin`(self[, axis, fill_value, out])	Return array of indices to the minimum values along the given axis.
`ma.max`(obj[, axis, out, fill_value, keepdims])	Return the maximum along a given axis.
`ma.min`(obj[, axis, out, fill_value, keepdims])	Return the minimum along a given axis.
`ma.ptp`(obj[, axis, out, fill_value, keepdims])	Return (maximum - minimum) along the given dimension (i.e. peak-to-peak value).
`ma.diff`(a, /[, n, axis, prepend, append])	Calculate the n-th discrete difference along the given axis.
`ma.MaskedArray.argmax`([axis, fill_value, ...])	Returns array of indices of the maximum values along the given axis.
`ma.MaskedArray.argmin`([axis, fill_value, ...])	Return array of indices to the minimum values along the given axis.
`ma.MaskedArray.max`([axis, out, fill_value, ...])	Return the maximum along a given axis.
`ma.MaskedArray.min`([axis, out, fill_value, ...])	Return the minimum along a given axis.
`ma.MaskedArray.ptp`([axis, out, fill_value, ...])	Return (maximum - minimum) along the given dimension (i.e. peak-to-peak value).

Sorting#

`ma.argsort`(a[, axis, kind, order, endwith, ...])	Return an ndarray of indices that sort the array along the specified axis.
`ma.sort`(a[, axis, kind, order, endwith, ...])	Return a sorted copy of the masked array.
`ma.MaskedArray.argsort`([axis, kind, order, ...])	Return an ndarray of indices that sort the array along the specified axis.
`ma.MaskedArray.sort`([axis, kind, order, ...])	Sort the array, in-place

Algebra#

`ma.diag`(v[, k])	Extract a diagonal or construct a diagonal array.
`ma.dot`(a, b[, strict, out])	Return the dot product of two arrays.
`ma.identity`(n[, dtype])	Return the identity array.
`ma.inner`(a, b, /)	Inner product of two arrays.
`ma.innerproduct`(a, b, /)	Inner product of two arrays.
`ma.outer`(a, b)	Compute the outer product of two vectors.
`ma.outerproduct`(a, b)	Compute the outer product of two vectors.
`ma.trace`(self[, offset, axis1, axis2, ...])	Return the sum along diagonals of the array.
`ma.transpose`(a[, axes])	Permute the dimensions of an array.
`ma.MaskedArray.trace`([offset, axis1, axis2, ...])	Return the sum along diagonals of the array.
`ma.MaskedArray.transpose`(*axes)	Returns a view of the array with axes transposed.

Polynomial fit#

`ma.vander`(x[, n])	Generate a Vandermonde matrix.
`ma.polyfit`(x, y, deg[, rcond, full, w, cov])	Least squares polynomial fit.

Clipping and rounding#

`ma.around`	Round an array to the given number of decimals.
`ma.clip`	Clip (limit) the values in an array.
`ma.round`(a[, decimals, out])	Return a copy of a, rounded to 'decimals' places.
`ma.MaskedArray.clip`([min, max, out])	Return an array whose values are limited to `[min, max]`.
`ma.MaskedArray.round`([decimals, out])	Return each element rounded to the given number of decimals.

Set operations#

`ma.intersect1d`(ar1, ar2[, assume_unique])	Returns the unique elements common to both arrays.
`ma.setdiff1d`(ar1, ar2[, assume_unique])	Set difference of 1D arrays with unique elements.
`ma.setxor1d`(ar1, ar2[, assume_unique])	Set exclusive-or of 1-D arrays with unique elements.
`ma.union1d`(ar1, ar2)	Union of two arrays.

Miscellanea#

`ma.allequal`(a, b[, fill_value])	Return True if all entries of a and b are equal, using fill_value as a truth value where either or both are masked.
`ma.allclose`(a, b[, masked_equal, rtol, atol])	Returns True if two arrays are element-wise equal within a tolerance.
`ma.amax`(a[, axis, out, keepdims, initial, where])	Return the maximum of an array or maximum along an axis.
`ma.amin`(a[, axis, out, keepdims, initial, where])	Return the minimum of an array or minimum along an axis.
`ma.apply_along_axis`(func1d, axis, arr, ...)	Apply a function to 1-D slices along the given axis.
`ma.apply_over_axes`(func, a, axes)	Apply a function repeatedly over multiple axes.
`ma.arange`([start,] stop[, step,][, dtype, ...])	Return evenly spaced values within a given interval.
`ma.choose`(indices, choices[, out, mode])	Use an index array to construct a new array from a list of choices.
`ma.compress_nd`(x[, axis])	Suppress slices from multiple dimensions which contain masked values.
`ma.convolve`(a, v[, mode, propagate_mask])	Returns the discrete, linear convolution of two one-dimensional sequences.
`ma.correlate`(a, v[, mode, propagate_mask])	Cross-correlation of two 1-dimensional sequences.
`ma.ediff1d`(arr[, to_end, to_begin])	Compute the differences between consecutive elements of an array.
`ma.flatten_mask`(mask)	Returns a completely flattened version of the mask, where nested fields are collapsed.
`ma.flatten_structured_array`(a)	Flatten a structured array.
`ma.fromflex`(fxarray)	Build a masked array from a suitable flexible-type array.
`ma.indices`(dimensions[, dtype, sparse])	Return an array representing the indices of a grid.
`ma.left_shift`(a, n)	Shift the bits of an integer to the left.
`ma.ndim`(obj)	Return the number of dimensions of an array.
`ma.put`(a, indices, values[, mode])	Set storage-indexed locations to corresponding values.
`ma.putmask`(a, mask, values)	Changes elements of an array based on conditional and input values.
`ma.right_shift`(a, n)	Shift the bits of an integer to the right.
`ma.round_`(a[, decimals, out])	Return a copy of a, rounded to 'decimals' places.
`ma.take`(a, indices[, axis, out, mode])
`ma.where`(condition[, x, y])	Return a masked array with elements from x or y, depending on condition.