### Table Of Contents

- Masked array operations
  - Constants
  - Creation
    - From existing data
    - Ones and zeros
  - Inspecting the array
  - Manipulating a MaskedArray
    - Changing the shape
    - Modifying axes
    - Changing the number of dimensions
    - Joining arrays
  - Operations on masks
    - Creating a mask
    - Accessing a mask
    - Finding masked data
    - Modifying a mask
  - Conversion operations
    - > to a masked array
    - > to a ndarray
    - > to another object
    - Pickling and unpickling
    - Filling a masked array
  - Masked arrays arithmetics
    - Arithmetics
    - Minimum/maximum
    - Sorting
    - Algebra
    - Polynomial fit
    - Clipping and rounding
    - Miscellanea

#### Previous topic

numpy.not_equal

#### Next topic

numpy.ma.MaskType

# Masked array operations

## Constants

`ma.MaskType` | Numpy’s Boolean type.

## Creation

### From existing data

`ma.masked_array` | An array class with possibly masked values.
`ma.array`(data[, dtype, copy, order, mask, ...]) | An array class with possibly masked values.
`ma.copy` | copy
`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`(a[, dtype, order, subok]) | 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]) | Check if all of the elements of a are true.
`ma.any`(self[, axis, out]) | Check if any of the elements of a are true.
`ma.count`(a[, axis]) | 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.data` | Return the current data, as a view of the original underlying data.
`ma.MaskedArray.mask` | Mask
`ma.MaskedArray.recordmask` | Return the mask of the records.
`ma.MaskedArray.all`([axis, out]) | Check if all of the elements of a are true.
`ma.MaskedArray.any`([axis, out]) | Check if any of the elements of a are true.
`ma.MaskedArray.count`([axis]) | 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.

## 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` | swapaxes
`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`(*arys) | Convert inputs to arrays with at least one dimension.
`ma.atleast_2d`(*arys) | View inputs as arrays with at least two dimensions.
`ma.atleast_3d`(*arys) | View inputs as arrays with at least three dimensions.
`ma.expand_dims`(x, 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.column_stack`(tup) | 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`(tup) | Stack arrays in sequence depth wise (along third axis).
`ma.hstack`(tup) | Stack arrays in sequence horizontally (column wise).
`ma.hsplit`(ary, indices_or_sections) | Split an array into multiple sub-arrays horizontally (column-wise).
`ma.mr_` | Translate slice objects to concatenation along the first axis.
`ma.row_stack`(tup) | Stack arrays in sequence vertically (row wise).
`ma.vstack`(tup) | Stack arrays in sequence vertically (row wise).

### Joining arrays

`ma.column_stack`(tup) | 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`(tup) | Stack arrays in sequence depth wise (along third axis).
`ma.hstack`(tup) | Stack arrays in sequence horizontally (column wise).
`ma.vstack`(tup) | 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` | 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`() | Force the mask to hard.
`ma.MaskedArray.soften_mask`() | Force the mask to soft.
`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 array with masked data replaced by a 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.

### 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`() | Return the filling value of the masked array.
`ma.MaskedArray.set_fill_value`([value]) | Set the filling value of the masked array.
`ma.MaskedArray.fill_value` | Filling value.

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

### Sorting

`ma.argsort`(a[, axis, kind, order, fill_value]) | 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 :Parameters: a : array_like Array to be sorted.
`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 :Parameters: a : array_like Array to be sorted.

### Algebra

`ma.diag`(v[, k]) | Extract a diagonal or construct a diagonal array.
`ma.dot`(a, b[, strict]) | 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`(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`([decimals, out]) | Return a with 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]) | 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.