neulab/docprompting-conala huggingface dataset:
numpy.ma.masked_equal   ma.masked_equal(x, value, copy=True)[source]
 
Mask an array where equal to a given value. This function is a shortcut to masked_where, with condition = (x == value). For floating point arrays, consider using masked_values(x, value).  See also  masked_where

Mask where a condition is met.  masked_values

Mask using floating point equality.    Examples >>> import numpy.ma as ma
>>> a = np.arange(4)
>>> a
array([0, 1, 2, 3])
>>> ma.masked_equal(a, 2)
masked_array(data=[0, 1, --, 3],
             mask=[False, False,  True, False],
       fill_value=2)
numpy.ma.masked_greater   ma.masked_greater(x, value, copy=True)[source]
 
Mask an array where greater than a given value. This function is a shortcut to masked_where, with condition = (x > value).  See also  masked_where

Mask where a condition is met.    Examples >>> import numpy.ma as ma
>>> a = np.arange(4)
>>> a
array([0, 1, 2, 3])
>>> ma.masked_greater(a, 2)
masked_array(data=[0, 1, 2, --],
             mask=[False, False, False,  True],
       fill_value=999999)
numpy.ma.masked_greater_equal   ma.masked_greater_equal(x, value, copy=True)[source]
 
Mask an array where greater than or equal to a given value. This function is a shortcut to masked_where, with condition = (x >= value).  See also  masked_where

Mask where a condition is met.    Examples >>> import numpy.ma as ma
>>> a = np.arange(4)
>>> a
array([0, 1, 2, 3])
>>> ma.masked_greater_equal(a, 2)
masked_array(data=[0, 1, --, --],
             mask=[False, False,  True,  True],
       fill_value=999999)
numpy.ma.masked_inside   ma.masked_inside(x, v1, v2, copy=True)[source]
 
Mask an array inside a given interval. Shortcut to masked_where, where condition is True for x inside the interval [v1,v2] (v1 <= x <= v2). The boundaries v1 and v2 can be given in either order.  See also  masked_where

Mask where a condition is met.    Notes The array x is prefilled with its filling value. Examples >>> import numpy.ma as ma
>>> x = [0.31, 1.2, 0.01, 0.2, -0.4, -1.1]
>>> ma.masked_inside(x, -0.3, 0.3)
masked_array(data=[0.31, 1.2, --, --, -0.4, -1.1],
             mask=[False, False,  True,  True, False, False],
       fill_value=1e+20)
 The order of v1 and v2 doesn’t matter. >>> ma.masked_inside(x, 0.3, -0.3)
masked_array(data=[0.31, 1.2, --, --, -0.4, -1.1],
             mask=[False, False,  True,  True, False, False],
       fill_value=1e+20)
numpy.ma.masked_invalid   ma.masked_invalid(a, copy=True)[source]
 
Mask an array where invalid values occur (NaNs or infs). This function is a shortcut to masked_where, with condition = ~(np.isfinite(a)). Any pre-existing mask is conserved. Only applies to arrays with a dtype where NaNs or infs make sense (i.e. floating point types), but accepts any array_like object.  See also  masked_where

Mask where a condition is met.    Examples >>> import numpy.ma as ma
>>> a = np.arange(5, dtype=float)
>>> a[2] = np.NaN
>>> a[3] = np.PINF
>>> a
array([ 0.,  1., nan, inf,  4.])
>>> ma.masked_invalid(a)
masked_array(data=[0.0, 1.0, --, --, 4.0],
             mask=[False, False,  True,  True, False],
       fill_value=1e+20)
numpy.ma.masked_less   ma.masked_less(x, value, copy=True)[source]
 
Mask an array where less than a given value. This function is a shortcut to masked_where, with condition = (x < value).  See also  masked_where

Mask where a condition is met.    Examples >>> import numpy.ma as ma
>>> a = np.arange(4)
>>> a
array([0, 1, 2, 3])
>>> ma.masked_less(a, 2)
masked_array(data=[--, --, 2, 3],
             mask=[ True,  True, False, False],
       fill_value=999999)
numpy.ma.masked_less_equal   ma.masked_less_equal(x, value, copy=True)[source]
 
Mask an array where less than or equal to a given value. This function is a shortcut to masked_where, with condition = (x <= value).  See also  masked_where

Mask where a condition is met.    Examples >>> import numpy.ma as ma
>>> a = np.arange(4)
>>> a
array([0, 1, 2, 3])
>>> ma.masked_less_equal(a, 2)
masked_array(data=[--, --, --, 3],
             mask=[ True,  True,  True, False],
       fill_value=999999)
numpy.ma.masked_not_equal   ma.masked_not_equal(x, value, copy=True)[source]
 
Mask an array where not equal to a given value. This function is a shortcut to masked_where, with condition = (x != value).  See also  masked_where

Mask where a condition is met.    Examples >>> import numpy.ma as ma
>>> a = np.arange(4)
>>> a
array([0, 1, 2, 3])
>>> ma.masked_not_equal(a, 2)
masked_array(data=[--, --, 2, --],
             mask=[ True,  True, False,  True],
       fill_value=999999)
numpy.ma.masked_object   ma.masked_object(x, value, copy=True, shrink=True)[source]
 
Mask the array x where the data are exactly equal to value. This function is similar to masked_values, but only suitable for object arrays: for floating point, use masked_values instead.  Parameters 
 
xarray_like


Array to mask  
valueobject


Comparison value  
copy{True, False}, optional


Whether to return a copy of x.  
shrink{True, False}, optional


Whether to collapse a mask full of False to nomask    Returns 
 
resultMaskedArray


The result of masking x where equal to value.      See also  masked_where

Mask where a condition is met.  masked_equal

Mask where equal to a given value (integers).  masked_values

Mask using floating point equality.    Examples >>> import numpy.ma as ma
>>> food = np.array(['green_eggs', 'ham'], dtype=object)
>>> # don't eat spoiled food
>>> eat = ma.masked_object(food, 'green_eggs')
>>> eat
masked_array(data=[--, 'ham'],
             mask=[ True, False],
       fill_value='green_eggs',
            dtype=object)
>>> # plain ol` ham is boring
>>> fresh_food = np.array(['cheese', 'ham', 'pineapple'], dtype=object)
>>> eat = ma.masked_object(fresh_food, 'green_eggs')
>>> eat
masked_array(data=['cheese', 'ham', 'pineapple'],
             mask=False,
       fill_value='green_eggs',
            dtype=object)
 Note that mask is set to nomask if possible. >>> eat
masked_array(data=['cheese', 'ham', 'pineapple'],
             mask=False,
       fill_value='green_eggs',
            dtype=object)
numpy.ma.masked_outside   ma.masked_outside(x, v1, v2, copy=True)[source]
 
Mask an array outside a given interval. Shortcut to masked_where, where condition is True for x outside the interval [v1,v2] (x < v1)|(x > v2). The boundaries v1 and v2 can be given in either order.  See also  masked_where

Mask where a condition is met.    Notes The array x is prefilled with its filling value. Examples >>> import numpy.ma as ma
>>> x = [0.31, 1.2, 0.01, 0.2, -0.4, -1.1]
>>> ma.masked_outside(x, -0.3, 0.3)
masked_array(data=[--, --, 0.01, 0.2, --, --],
             mask=[ True,  True, False, False,  True,  True],
       fill_value=1e+20)
 The order of v1 and v2 doesn’t matter. >>> ma.masked_outside(x, 0.3, -0.3)
masked_array(data=[--, --, 0.01, 0.2, --, --],
             mask=[ True,  True, False, False,  True,  True],
       fill_value=1e+20)
numpy.ma.masked_values   ma.masked_values(x, value, rtol=1e-05, atol=1e-08, copy=True, shrink=True)[source]
 
Mask using floating point equality. Return a MaskedArray, masked where the data in array x are approximately equal to value, determined using isclose. The default tolerances for masked_values are the same as those for isclose. For integer types, exact equality is used, in the same way as masked_equal. The fill_value is set to value and the mask is set to nomask if possible.  Parameters 
 
xarray_like


Array to mask.  
valuefloat


Masking value.  
rtol, atolfloat, optional


Tolerance parameters passed on to isclose  
copybool, optional


Whether to return a copy of x.  
shrinkbool, optional


Whether to collapse a mask full of False to nomask.    Returns 
 
resultMaskedArray


The result of masking x where approximately equal to value.      See also  masked_where

Mask where a condition is met.  masked_equal

Mask where equal to a given value (integers).    Examples >>> import numpy.ma as ma
>>> x = np.array([1, 1.1, 2, 1.1, 3])
>>> ma.masked_values(x, 1.1)
masked_array(data=[1.0, --, 2.0, --, 3.0],
             mask=[False,  True, False,  True, False],
       fill_value=1.1)
 Note that mask is set to nomask if possible. >>> ma.masked_values(x, 1.5)
masked_array(data=[1. , 1.1, 2. , 1.1, 3. ],
             mask=False,
       fill_value=1.5)
 For integers, the fill value will be different in general to the result of masked_equal. >>> x = np.arange(5)
>>> x
array([0, 1, 2, 3, 4])
>>> ma.masked_values(x, 2)
masked_array(data=[0, 1, --, 3, 4],
             mask=[False, False,  True, False, False],
       fill_value=2)
>>> ma.masked_equal(x, 2)
masked_array(data=[0, 1, --, 3, 4],
             mask=[False, False,  True, False, False],
       fill_value=2)
numpy.ma.masked_where   ma.masked_where(condition, a, copy=True)[source]
 
Mask an array where a condition is met. Return a as an array masked where condition is True. Any masked values of a or condition are also masked in the output.  Parameters 
 
conditionarray_like


Masking condition. When condition tests floating point values for equality, consider using masked_values instead.  
aarray_like


Array to mask.  
copybool


If True (default) make a copy of a in the result. If False modify a in place and return a view.    Returns 
 
resultMaskedArray


The result of masking a where condition is True.      See also  masked_values

Mask using floating point equality.  masked_equal

Mask where equal to a given value.  masked_not_equal

Mask where not equal to a given value.  masked_less_equal

Mask where less than or equal to a given value.  masked_greater_equal

Mask where greater than or equal to a given value.  masked_less

Mask where less than a given value.  masked_greater

Mask where greater than a given value.  masked_inside

Mask inside a given interval.  masked_outside

Mask outside a given interval.  masked_invalid

Mask invalid values (NaNs or infs).    Examples >>> import numpy.ma as ma
>>> a = np.arange(4)
>>> a
array([0, 1, 2, 3])
>>> ma.masked_where(a <= 2, a)
masked_array(data=[--, --, --, 3],
             mask=[ True,  True,  True, False],
       fill_value=999999)
 Mask array b conditional on a. >>> b = ['a', 'b', 'c', 'd']
>>> ma.masked_where(a == 2, b)
masked_array(data=['a', 'b', --, 'd'],
             mask=[False, False,  True, False],
       fill_value='N/A',
            dtype='<U1')
 Effect of the copy argument. >>> c = ma.masked_where(a <= 2, a)
>>> c
masked_array(data=[--, --, --, 3],
             mask=[ True,  True,  True, False],
       fill_value=999999)
>>> c[0] = 99
>>> c
masked_array(data=[99, --, --, 3],
             mask=[False,  True,  True, False],
       fill_value=999999)
>>> a
array([0, 1, 2, 3])
>>> c = ma.masked_where(a <= 2, a, copy=False)
>>> c[0] = 99
>>> c
masked_array(data=[99, --, --, 3],
             mask=[False,  True,  True, False],
       fill_value=999999)
>>> a
array([99,  1,  2,  3])
 When condition or a contain masked values. >>> a = np.arange(4)
>>> a = ma.masked_where(a == 2, a)
>>> a
masked_array(data=[0, 1, --, 3],
             mask=[False, False,  True, False],
       fill_value=999999)
>>> b = np.arange(4)
>>> b = ma.masked_where(b == 0, b)
>>> b
masked_array(data=[--, 1, 2, 3],
             mask=[ True, False, False, False],
       fill_value=999999)
>>> ma.masked_where(a == 3, b)
masked_array(data=[--, 1, --, --],
             mask=[ True, False,  True,  True],
       fill_value=999999)
numpy.ma.MaskedArray.__abs__ method   ma.MaskedArray.__abs__(self)
numpy.ma.MaskedArray.__add__ method   ma.MaskedArray.__add__(other)[source]
 
Add self to other, and return a new masked array.
numpy.ma.MaskedArray.__and__ method   ma.MaskedArray.__and__(value, /)
 
Return self&value.
numpy.ma.MaskedArray.__array__ method   ma.MaskedArray.__array__([dtype, ]/) → reference if type unchanged, copy otherwise.
 
Returns either a new reference to self if dtype is not given or a new array of provided data type if dtype is different from the current dtype of the array.
numpy.ma.MaskedArray.__array_priority__ attribute   ma.MaskedArray.__array_priority__ = 15
numpy.ma.MaskedArray.__array_wrap__ method   ma.MaskedArray.__array_wrap__(obj, context=None)[source]
 
Special hook for ufuncs. Wraps the numpy array and sets the mask according to context.
numpy.ma.MaskedArray.__bool__ method   ma.MaskedArray.__bool__(/)
 
self != 0
numpy.ma.MaskedArray.__contains__ method   ma.MaskedArray.__contains__(key, /)
 
Return key in self.
numpy.ma.MaskedArray.__copy__ method   ma.MaskedArray.__copy__()
 
Used if copy.copy is called on an array. Returns a copy of the array. Equivalent to a.copy(order='K').
numpy.ma.MaskedArray.__deepcopy__ method   ma.MaskedArray.__deepcopy__(memo, /) → Deep copy of array.[source]
 
Used if copy.deepcopy is called on an array.
numpy.ma.MaskedArray.__delitem__ method   ma.MaskedArray.__delitem__(key, /)
 
Delete self[key].
numpy.ma.MaskedArray.__div__ method   ma.MaskedArray.__div__(other)[source]
 
Divide other into self, and return a new masked array.
numpy.ma.MaskedArray.__divmod__ method   ma.MaskedArray.__divmod__(value, /)
 
Return divmod(self, value).
numpy.ma.MaskedArray.__eq__ method   ma.MaskedArray.__eq__(other)[source]
 
Check whether other equals self elementwise. When either of the elements is masked, the result is masked as well, but the underlying boolean data are still set, with self and other considered equal if both are masked, and unequal otherwise. For structured arrays, all fields are combined, with masked values ignored. The result is masked if all fields were masked, with self and other considered equal only if both were fully masked.
numpy.ma.MaskedArray.__float__ method   ma.MaskedArray.__float__()[source]
 
Convert to float.
numpy.ma.MaskedArray.__floordiv__ method   ma.MaskedArray.__floordiv__(other)[source]
 
Divide other into self, and return a new masked array.
numpy.ma.MaskedArray.__ge__ method   ma.MaskedArray.__ge__(value, /)
 
Return self>=value.
numpy.ma.MaskedArray.__getitem__ method   ma.MaskedArray.__getitem__(indx)[source]
 
x.__getitem__(y) <==> x[y] Return the item described by i, as a masked array.
numpy.ma.MaskedArray.__getstate__ method   ma.MaskedArray.__getstate__()[source]
 
Return the internal state of the masked array, for pickling purposes.
numpy.ma.MaskedArray.__gt__ method   ma.MaskedArray.__gt__(value, /)
 
Return self>value.
numpy.ma.MaskedArray.__iadd__ method   ma.MaskedArray.__iadd__(other)[source]
 
Add other to self in-place.
numpy.ma.MaskedArray.__iand__ method   ma.MaskedArray.__iand__(value, /)
 
Return self&=value.
numpy.ma.MaskedArray.__idiv__ method   ma.MaskedArray.__idiv__(other)[source]
 
Divide self by other in-place.
numpy.ma.MaskedArray.__ifloordiv__ method   ma.MaskedArray.__ifloordiv__(other)[source]
 
Floor divide self by other in-place.
numpy.ma.MaskedArray.__ilshift__ method   ma.MaskedArray.__ilshift__(value, /)
 
Return self<<=value.
numpy.ma.MaskedArray.__imod__ method   ma.MaskedArray.__imod__(value, /)
 
Return self%=value.
numpy.ma.MaskedArray.__imul__ method   ma.MaskedArray.__imul__(other)[source]
 
Multiply self by other in-place.
numpy.ma.MaskedArray.__int__ method   ma.MaskedArray.__int__()[source]
 
Convert to int.
numpy.ma.MaskedArray.__ior__ method   ma.MaskedArray.__ior__(value, /)
 
Return self|=value.
numpy.ma.MaskedArray.__ipow__ method   ma.MaskedArray.__ipow__(other)[source]
 
Raise self to the power other, in place.
numpy.ma.MaskedArray.__irshift__ method   ma.MaskedArray.__irshift__(value, /)
 
Return self>>=value.
numpy.ma.MaskedArray.__isub__ method   ma.MaskedArray.__isub__(other)[source]
 
Subtract other from self in-place.
numpy.ma.MaskedArray.__itruediv__ method   ma.MaskedArray.__itruediv__(other)[source]
 
True divide self by other in-place.
numpy.ma.MaskedArray.__ixor__ method   ma.MaskedArray.__ixor__(value, /)
 
Return self^=value.
numpy.ma.MaskedArray.__le__ method   ma.MaskedArray.__le__(value, /)
 
Return self<=value.
numpy.ma.MaskedArray.__len__ method   ma.MaskedArray.__len__(/)
 
Return len(self).
numpy.ma.MaskedArray.__lshift__ method   ma.MaskedArray.__lshift__(value, /)
 
Return self<<value.
numpy.ma.MaskedArray.__lt__ method   ma.MaskedArray.__lt__(value, /)
 
Return self<value.
numpy.ma.MaskedArray.__mod__ method   ma.MaskedArray.__mod__(value, /)
 
Return self%value.
numpy.ma.MaskedArray.__mul__ method   ma.MaskedArray.__mul__(other)[source]
 
Multiply self by other, and return a new masked array.
numpy.ma.MaskedArray.__ne__ method   ma.MaskedArray.__ne__(other)[source]
 
Check whether other does not equal self elementwise. When either of the elements is masked, the result is masked as well, but the underlying boolean data are still set, with self and other considered equal if both are masked, and unequal otherwise. For structured arrays, all fields are combined, with masked values ignored. The result is masked if all fields were masked, with self and other considered equal only if both were fully masked.
numpy.ma.MaskedArray.__or__ method   ma.MaskedArray.__or__(value, /)
 
Return self|value.
numpy.ma.MaskedArray.__pow__ method   ma.MaskedArray.__pow__(other)[source]
 
Raise self to the power other, masking the potential NaNs/Infs
numpy.ma.MaskedArray.__radd__ method   ma.MaskedArray.__radd__(other)[source]
 
Add other to self, and return a new masked array.
numpy.ma.MaskedArray.__rand__ method   ma.MaskedArray.__rand__(value, /)
 
Return value&self.
numpy.ma.MaskedArray.__rdivmod__ method   ma.MaskedArray.__rdivmod__(value, /)
 
Return divmod(value, self).
numpy.ma.MaskedArray.__reduce__ method   ma.MaskedArray.__reduce__()[source]
 
Return a 3-tuple for pickling a MaskedArray.
numpy.ma.MaskedArray.__repr__ method   ma.MaskedArray.__repr__()[source]
 
Literal string representation.
numpy.ma.MaskedArray.__rfloordiv__ method   ma.MaskedArray.__rfloordiv__(other)[source]
 
Divide self into other, and return a new masked array.
numpy.ma.MaskedArray.__rlshift__ method   ma.MaskedArray.__rlshift__(value, /)
 
Return value<<self.
numpy.ma.MaskedArray.__rmod__ method   ma.MaskedArray.__rmod__(value, /)
 
Return value%self.
numpy.ma.MaskedArray.__rmul__ method   ma.MaskedArray.__rmul__(other)[source]
 
Multiply other by self, and return a new masked array.
numpy.ma.MaskedArray.__ror__ method   ma.MaskedArray.__ror__(value, /)
 
Return value|self.
numpy.ma.MaskedArray.__rpow__ method   ma.MaskedArray.__rpow__(other)[source]
 
Raise other to the power self, masking the potential NaNs/Infs
numpy.ma.MaskedArray.__rrshift__ method   ma.MaskedArray.__rrshift__(value, /)
 
Return value>>self.
numpy.ma.MaskedArray.__rshift__ method   ma.MaskedArray.__rshift__(value, /)
 
Return self>>value.
numpy.ma.MaskedArray.__rsub__ method   ma.MaskedArray.__rsub__(other)[source]
 
Subtract self from other, and return a new masked array.
numpy.ma.MaskedArray.__rtruediv__ method   ma.MaskedArray.__rtruediv__(other)[source]
 
Divide self into other, and return a new masked array.
numpy.ma.MaskedArray.__rxor__ method   ma.MaskedArray.__rxor__(value, /)
 
Return value^self.
numpy.ma.MaskedArray.__setitem__ method   ma.MaskedArray.__setitem__(indx, value)[source]
 
x.__setitem__(i, y) <==> x[i]=y Set item described by index. If value is masked, masks those locations.
numpy.ma.MaskedArray.__setmask__ method   ma.MaskedArray.__setmask__(mask, copy=False)[source]
 
Set the mask.
numpy.ma.MaskedArray.__setstate__ method   ma.MaskedArray.__setstate__(state)[source]
 
Restore the internal state of the masked array, for pickling purposes. state is typically the output of the __getstate__ output, and is a 5-tuple:  class name a tuple giving the shape of the data a typecode for the data a binary string for the data a binary string for the mask.
numpy.ma.MaskedArray.__str__ method   ma.MaskedArray.__str__()[source]
 
Return str(self).
numpy.ma.MaskedArray.__sub__ method   ma.MaskedArray.__sub__(other)[source]
 
Subtract other from self, and return a new masked array.
numpy.ma.MaskedArray.__truediv__ method   ma.MaskedArray.__truediv__(other)[source]
 
Divide other into self, and return a new masked array.
numpy.ma.MaskedArray.__xor__ method   ma.MaskedArray.__xor__(value, /)
 
Return self^value.
numpy.ma.MaskedArray.all method   ma.MaskedArray.all(axis=None, out=None, keepdims=<no value>)[source]
 
Returns True if all elements evaluate to True. The output array is masked where all the values along the given axis are masked: if the output would have been a scalar and that all the values are masked, then the output is masked. Refer to numpy.all for full documentation.  See also  numpy.ndarray.all

corresponding function for ndarrays  numpy.all

equivalent function    Examples >>> np.ma.array([1,2,3]).all()
True
>>> a = np.ma.array([1,2,3], mask=True)
>>> (a.all() is np.ma.masked)
True
numpy.ma.MaskedArray.anom method   ma.MaskedArray.anom(axis=None, dtype=None)[source]
 
Compute the anomalies (deviations from the arithmetic mean) along the given axis. Returns an array of anomalies, with the same shape as the input and where the arithmetic mean is computed along the given axis.  Parameters 
 
axisint, optional


Axis over which the anomalies are taken. The default is to use the mean of the flattened array as reference.  
dtypedtype, optional


 Type to use in computing the variance. For arrays of integer type

the default is float32; for arrays of float types it is the same as the array type.        See also  mean

Compute the mean of the array.    Examples >>> a = np.ma.array([1,2,3])
>>> a.anom()
masked_array(data=[-1.,  0.,  1.],
             mask=False,
       fill_value=1e+20)
numpy.ma.MaskedArray.any method   ma.MaskedArray.any(axis=None, out=None, keepdims=<no value>)[source]
 
Returns True if any of the elements of a evaluate to True. Masked values are considered as False during computation. Refer to numpy.any for full documentation.  See also  numpy.ndarray.any

corresponding function for ndarrays  numpy.any

equivalent function
numpy.ma.MaskedArray.argmax method   ma.MaskedArray.argmax(axis=None, fill_value=None, out=None, *, keepdims=<no value>)[source]
 
Returns array of indices of the maximum values along the given axis. Masked values are treated as if they had the value fill_value.  Parameters 
 
axis{None, integer}


If None, the index is into the flattened array, otherwise along the specified axis  
fill_valuescalar or None, optional


Value used to fill in the masked values. If None, the output of maximum_fill_value(self._data) is used instead.  
out{None, array}, optional


Array into which the result can be placed. Its type is preserved and it must be of the right shape to hold the output.    Returns 
 
index_array{integer_array}

   Examples >>> a = np.arange(6).reshape(2,3)
>>> a.argmax()
5
>>> a.argmax(0)
array([1, 1, 1])
>>> a.argmax(1)
array([2, 2])
numpy.ma.MaskedArray.argmin method   ma.MaskedArray.argmin(axis=None, fill_value=None, out=None, *, keepdims=<no value>)[source]
 
Return array of indices to the minimum values along the given axis.  Parameters 
 
axis{None, integer}


If None, the index is into the flattened array, otherwise along the specified axis  
fill_valuescalar or None, optional


Value used to fill in the masked values. If None, the output of minimum_fill_value(self._data) is used instead.  
out{None, array}, optional


Array into which the result can be placed. Its type is preserved and it must be of the right shape to hold the output.    Returns 
 ndarray or scalar

If multi-dimension input, returns a new ndarray of indices to the minimum values along the given axis. Otherwise, returns a scalar of index to the minimum values along the given axis.     Examples >>> x = np.ma.array(np.arange(4), mask=[1,1,0,0])
>>> x.shape = (2,2)
>>> x
masked_array(
  data=[[--, --],
        [2, 3]],
  mask=[[ True,  True],
        [False, False]],
  fill_value=999999)
>>> x.argmin(axis=0, fill_value=-1)
array([0, 0])
>>> x.argmin(axis=0, fill_value=9)
array([1, 1])