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.