numpy.ma.count(a, axis=None) [source] Count the non-masked elements of the array along the given axis. Parameters: axis : int, optional Axis along which to count the non-masked elements. If axis is None, all non-masked elements are counted. Returns: result : int or ndarray If axis is None, an integer count is returned. When axis is not None, an array with shape determined by the lengths of the remaining axes, is returned. See also count_masked Count masked elements in array or a

numpy.ma.copy(self, *args, **params) a.copy(order='C') = Return a copy of the array. Parameters: order : {?C?, ?F?, ?A?, ?K?}, optional Controls the memory layout of the copy. ?C? means C-order, ?F? means F-order, ?A? means ?F? if a is Fortran contiguous, ?C? otherwise. ?K? means match the layout of a as closely as possible. (Note that this function and :func:numpy.copy are very similar, but have different default values for their order= arguments.) Examples >>> x = np.array([

numpy.ma.corrcoef(x, y=None, rowvar=True, bias=, allow_masked=True, ddof=) [source] Return Pearson product-moment correlation coefficients. Except for the handling of missing data this function does the same as numpy.corrcoef. For more details and examples, see numpy.corrcoef. Parameters: x : array_like A 1-D or 2-D array containing multiple variables and observations. Each row of x represents a variable, and each column a single observation of all those variables. Also see rowvar below.

numpy.ma.conjugate(x[, out]) = Return the complex conjugate, element-wise. The complex conjugate of a complex number is obtained by changing the sign of its imaginary part. Parameters: x : array_like Input value. Returns: y : ndarray The complex conjugate of x, with same dtype as y. Examples >>> np.conjugate(1+2j) (1-2j) >>> x = np.eye(2) + 1j * np.eye(2) >>> np.conjugate(x) array([[ 1.-1.j, 0.-0.j], [ 0.-0.j, 1.-1.j]])

numpy.ma.concatenate(arrays, axis=0) [source] Concatenate a sequence of arrays along the given axis. Parameters: arrays : sequence of array_like The arrays must have the same shape, except in the dimension corresponding to axis (the first, by default). axis : int, optional The axis along which the arrays will be joined. Default is 0. Returns: result : MaskedArray The concatenated array with any masked entries preserved. See also numpy.concatenate Equivalent function in the top

numpy.ma.compress_rows(a) [source] Suppress whole rows of a 2-D array that contain masked values. This is equivalent to np.ma.compress_rowcols(a, 0), see extras.compress_rowcols for details. See also extras.compress_rowcols

numpy.ma.compressed(x) [source] Return all the non-masked data as a 1-D array. This function is equivalent to calling the ?compressed? method of a MaskedArray, see MaskedArray.compressed for details. See also MaskedArray.compressed Equivalent method.

numpy.ma.compress_cols(a) [source] Suppress whole columns of a 2-D array that contain masked values. This is equivalent to np.ma.compress_rowcols(a, 1), see extras.compress_rowcols for details. See also extras.compress_rowcols

numpy.ma.compress_rowcols(x, axis=None) [source] Suppress the rows and/or columns of a 2-D array that contain masked values. The suppression behavior is selected with the axis parameter. If axis is None, both rows and columns are suppressed. If axis is 0, only rows are suppressed. If axis is 1 or -1, only columns are suppressed. Parameters: x : array_like, MaskedArray The array to operate on. If not a MaskedArray instance (or if no array elements are masked), x is interpreted as a MaskedA

numpy.ma.column_stack(tup) = Stack 1-D arrays as columns into a 2-D array. Take a sequence of 1-D arrays and stack them as columns to make a single 2-D array. 2-D arrays are stacked as-is, just like with hstack. 1-D arrays are turned into 2-D columns first. Parameters: tup : sequence of 1-D or 2-D arrays. Arrays to stack. All of them must have the same first dimension. Returns: stacked : 2-D array The array formed by stacking the given arrays. Notes The function is applied to both