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.