Masked array operations

Constants

ma.MaskType

alias of numpy.bool_

Creation

From existing data

ma.masked_array	alias of numpy.ma.core.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, offset])	Interpret a buffer as a 1-dimensional array.
ma.fromfunction(function, shape, **kwargs)	Construct an array by executing a function over each coordinate.
ma.MaskedArray.copy([order])	Return a copy of the array.

Ones and zeros

ma.empty(shape[, dtype, order])	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.zeros(shape[, dtype, order])	Return a new array of given shape and type, filled with zeros.

---

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.MaskedArray.all(self[, axis, out, keepdims])	Returns True if all elements evaluate to True.
ma.MaskedArray.any(self[, axis, out, keepdims])	Returns True if any of the elements of a evaluate to True.
ma.MaskedArray.count(self[, axis, keepdims])	Count the non-masked elements of the array along the given axis.
ma.MaskedArray.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.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(self[, order])	Returns a 1D version of self, as a view.
ma.MaskedArray.reshape(self, \*s, \*\*kwargs)	Give a new shape to the array without changing its data.
ma.MaskedArray.resize(self, newshape[, …])

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(*args, **kwargs)	Convert inputs to arrays with at least one dimension.
ma.atleast_2d(*args, **kwargs)	View inputs as arrays with at least two dimensions.
ma.atleast_3d(*args, **kwargs)	View inputs as arrays with at least three dimensions.
ma.expand_dims(a, axis)	Expand the shape of an array.
ma.squeeze(a[, axis])	Remove single-dimensional entries from the shape of an array.
ma.MaskedArray.squeeze([axis])	Remove single-dimensional entries from the shape of a.
ma.stack(*args, **kwargs)	Join a sequence of arrays along a new axis.
ma.column_stack(*args, **kwargs)	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(*args, **kwargs)	Stack arrays in sequence depth wise (along third axis).
ma.hstack(*args, **kwargs)	Stack arrays in sequence horizontally (column wise).
ma.hsplit(*args, **kwargs)	Split an array into multiple sub-arrays horizontally (column-wise).
ma.mr_	Translate slice objects to concatenation along the first axis.
ma.row_stack(*args, **kwargs)	Stack arrays in sequence vertically (row wise).
ma.vstack(*args, **kwargs)	Stack arrays in sequence vertically (row wise).

Joining arrays

ma.stack(*args, **kwargs)	Join a sequence of arrays along a new axis.
ma.column_stack(*args, **kwargs)	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.append(a, b[, axis])	Append values to the end of an array.
ma.dstack(*args, **kwargs)	Stack arrays in sequence depth wise (along third axis).
ma.hstack(*args, **kwargs)	Stack arrays in sequence horizontally (column wise).
ma.vstack(*args, **kwargs)	Stack arrays in sequence vertically (row wise).

---

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.flatnotmasked_contiguous(a)	Find contiguous unmasked data in a masked array along the given axis.
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.
ma.soften_mask(self)	Force the mask to soft.
ma.MaskedArray.harden_mask(self)	Force the mask to hard.
ma.MaskedArray.soften_mask(self)	Force the mask to soft.
ma.MaskedArray.shrink_mask(self)	Reduce a mask to nomask when possible.
ma.MaskedArray.unshare_mask(self)	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 array with masked data replaced by a fill value.
ma.MaskedArray.compressed(self)	Return all the non-masked data as a 1-D array.
ma.MaskedArray.filled(self[, fill_value])	Return a copy of self, with masked values filled with a given value.

> to another object

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

Pickling and unpickling

ma.dump(a, F)	Pickle a masked array to a file.
ma.dumps(a)	Return a string corresponding to the pickling of a masked array.
ma.load(F)	Wrapper around cPickle.load which accepts either a file-like object or a filename.
ma.loads(strg)	Load a pickle from the current string.

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.maximum_fill_value(obj)	Return the minimum 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(self)	The filling value of the masked array is a scalar.
ma.MaskedArray.set_fill_value(self[, value])

ma.MaskedArray.fill_value

The filling value of the masked array is a scalar.

---

Masked arrays arithmetics

Arithmetics

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, keepdims])	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, keepdims])	Compute the variance along the specified axis.
ma.MaskedArray.anom(self[, axis, dtype])	Compute the anomalies (deviations from the arithmetic mean) along the given axis.
ma.MaskedArray.cumprod(self[, axis, dtype, out])	Return the cumulative product of the array elements over the given axis.
ma.MaskedArray.cumsum(self[, axis, dtype, out])	Return the cumulative sum of the array elements over the given axis.
ma.MaskedArray.mean(self[, axis, dtype, …])	Returns the average of the array elements along given axis.
ma.MaskedArray.prod(self[, axis, dtype, …])	Return the product of the array elements over the given axis.
ma.MaskedArray.std(self[, axis, dtype, out, …])	Returns the standard deviation of the array elements along given axis.
ma.MaskedArray.sum(self[, axis, dtype, out, …])	Return the sum of the array elements over the given axis.
ma.MaskedArray.var(self[, axis, dtype, out, …])	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.
ma.MaskedArray.argmax(self[, axis, …])	Returns array of indices of the maximum values along the given axis.
ma.MaskedArray.argmin(self[, axis, …])	Return array of indices to the minimum values along the given axis.
ma.MaskedArray.max(self[, axis, out, …])	Return the maximum along a given axis.
ma.MaskedArray.min(self[, axis, out, …])	Return the minimum along a given axis.
ma.MaskedArray.ptp(self[, axis, out, …])	Return (maximum - minimum) along the given dimension (i.e.

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, …])	Sort the array, in-place
ma.MaskedArray.argsort(self[, axis, kind, …])	Return an ndarray of indices that sort the array along the specified axis.
ma.MaskedArray.sort(self[, axis, kind, …])	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(a, \*args, \*\*kwargs)	Round an array to the given number of decimals.
ma.clip(a, a_min, a_max[, out])	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(self[, decimals, out])	Return each element rounded to the given number of decimals.

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.apply_along_axis(func1d, axis, arr, …)	Apply a function to 1-D slices along the given axis.
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 set of choices.
ma.ediff1d(arr[, to_end, to_begin])	Compute the differences between consecutive elements of an array.
ma.indices(dimensions[, dtype, sparse])	Return an array representing the indices of a grid.
ma.where(condition[, x, y])	Return a masked array with elements from x or y, depending on condition.