numpy.oldnumeric.ma
index
/usr/lib/python2.6/dist-packages/numpy/oldnumeric/ma.py

MA: a facility for dealing with missing observations
MA is generally used as a numpy.array look-alike.
by Paul F. Dubois.
 
Copyright 1999, 2000, 2001 Regents of the University of California.
Released for unlimited redistribution.
Adapted for numpy_core 2005 by Travis Oliphant and
(mainly) Paul Dubois.

 
Modules
       
numpy.core.fromnumeric
numpy.core.numeric
sys
types
numpy.core.umath
warnings

 
Classes
       
object
MaskedArray
MaskedArray
Exception(BaseException)
MAError
_MaskedPrintOption
_maximum_operation
_minimum_operation
domain_check_interval
domain_greater
domain_greater_equal
domain_safe_divide
domain_tan
domained_binary_operation
masked_binary_operation
masked_unary_operation

 
class MAError(Exception)
    
Method resolution order:
MAError
Exception
BaseException
object

Methods defined here:
__init__(self, args=None)
Create an exception
__repr__ = __str__(self)
__str__(self)
Calculate the string representation

Data descriptors defined here:
__weakref__
list of weak references to the object (if defined)

Data and other attributes inherited from Exception:
__new__ = <built-in method __new__ of type object at 0x8108c0>
T.__new__(S, ...) -> a new object with type S, a subtype of T

Methods inherited from BaseException:
__delattr__(...)
x.__delattr__('name') <==> del x.name
__getattribute__(...)
x.__getattribute__('name') <==> x.name
__getitem__(...)
x.__getitem__(y) <==> x[y]
__getslice__(...)
x.__getslice__(i, j) <==> x[i:j]
 
Use of negative indices is not supported.
__reduce__(...)
__setattr__(...)
x.__setattr__('name', value) <==> x.name = value
__setstate__(...)
__unicode__(...)

Data descriptors inherited from BaseException:
__dict__
args
message

 
class MaskedArray(object)
    Arrays with possibly masked values.
Masked values of 1 exclude the corresponding element from
any computation.
 
Construction:
    x = array(data, dtype=None, copy=True, order=False,
              mask = nomask, fill_value=None)
 
If copy=False, every effort is made not to copy the data:
    If data is a MaskedArray, and argument mask=nomask,
    then the candidate data is data.data and the
    mask used is data.mask. If data is a numeric array,
    it is used as the candidate raw data.
    If dtype is not None and
    is != data.dtype.char then a data copy is required.
    Otherwise, the candidate is used.
 
If a data copy is required, raw data stored is the result of:
numeric.array(data, dtype=dtype.char, copy=copy)
 
If mask is nomask there are no masked values. Otherwise mask must
be convertible to an array of booleans with the same shape as x.
 
fill_value is used to fill in masked values when necessary,
such as when printing and in method/function filled().
The fill_value is not used for computation within this module.
 
  Methods defined here:
__abs__(self)
Return absolute(self)
__add__(self, other)
Return add(self, other)
__and__(self, other)
Return bitwise_and
__array__(self, t=None, context=None)
Special hook for numeric. Converts to numeric if possible.
__array_wrap__(self, array, context=None)
Special hook for ufuncs.
 
Wraps the numpy array and sets the mask according to
context.
__div__(self, other)
Return divide(self, other)
__eq__(self, other)
__float__(self)
Convert self to float.
__floordiv__(self, other)
Return divide(self, other)
__ge__(self, other)
__getitem__(self, i)
Get item described by i. Not a copy as in previous versions.
__gt__(self, other)
__iadd__(self, other)
Add other to self in place.
__idiv__(self, other)
Divide self by other in place.
__imul__(self, other)
Add other to self in place.
__init__(self, data, dtype=None, copy=True, order=False, mask=False, fill_value=None)
array(data, dtype=None, copy=True, order=False, mask=nomask, fill_value=None)
If data already a numeric array, its dtype becomes the default value of dtype.
__int__(self)
Convert self to int.
__isub__(self, other)
Subtract other from self in place.
__le__(self, other)
__len__(self)
Return length of first dimension. This is weird but Python's
slicing behavior depends on it.
__lshift__(self, n)
__lt__(self, other)
__mod__(self, other)
Return remainder(self, other)
__mul__(self, other)
Return multiply(self, other)
__ne__(self, other)
__neg__(self)
Return negative(self)
__nonzero__(self)
returns true if any element is non-zero or masked
__or__(self, other)
Return bitwise_or
__pos__(self)
Return array(self)
__pow__(self, other, third=None)
Return power(self, other, third)
__radd__ = __add__(self, other)
__rand__ = __and__(self, other)
__rdiv__(self, other)
Return divide(other, self)
__repr__(self)
Calculate the repr representation, using masked for fill if
it is enabled. Otherwise fill with fill value.
__rfloordiv__(self, other)
Return divide(other, self)
__rmod__(self, other)
Return remainder(other, self)
__rmul__ = __mul__(self, other)
__ror__ = __or__(self, other)
__rshift__(self, n)
__rsub__(self, other)
Return subtract(other, self)
__rtruediv__(self, other)
Return divide(other, self)
__rxor__ = __xor__(self, other)
__setitem__(self, index, value)
Set item described by index. If value is masked, mask those locations.
__sqrt__(self)
Return sqrt(self)
__str__(self)
Calculate the str representation, using masked for fill if
it is enabled. Otherwise fill with fill value.
__sub__(self, other)
Return subtract(self, other)
__truediv__(self, other)
Return divide(self, other)
__xor__(self, other)
Return bitwise_xor
all = reduce(...)
Reduce target along the given axis with this function.
any = reduce(...)
Reduce target along the given axis with this function.
argmax(x, axis=-1, out=None, fill_value=None)
Treating masked values as if they have the value fill_value,
return sort indices for maximum along given axis.
if fill_value is None, use -get_fill_value(x) if it exists.
Returns a numpy array if x has more than one dimension.
Otherwise, returns a scalar index.
argmin(x, axis=-1, out=None, fill_value=None)
Treating masked values as if they have the value fill_value,
return indices for minimum values along given axis.
if fill_value is None, use get_fill_value(x).
Returns a numpy array if x has more than one dimension.
Otherwise, returns a scalar index.
argsort(x, axis=-1, out=None, fill_value=None)
Treating masked values as if they have the value fill_value,
return sort indices for sorting along given axis.
if fill_value is None, use get_fill_value(x)
Returns a numpy array.
astype(self, tc)
return self as array of given type.
byte_swapped(self)
Returns the raw data field, byte_swapped. Included for consistency
with numeric but doesn't make sense in this context.
byteswap = not_implemented(*args, **kwds)
choose = _choose(self, *args, **kwds)
clip = _clip(self, a_min, a_max, out=None)
compress = _compress(self, cond, axis=None, out=None)
compressed(self)
A 1-D array of all the non-masked data.
conj = conjugate(...)
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)
conjugate(...)
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)
copy = not_implemented(*args, **kwds)
count(self, axis=None)
Count of the non-masked elements in a, or along a certain axis.
cumprod = _cumprod(self, axis=None, dtype=None, out=None)
cumsum = _cumsum(self, axis=None, dtype=None, out=None)
diagonal(a, k=0, axis1=0, axis2=1)
diagonal(a,k=0,axis1=0, axis2=1) = the k'th diagonal of a
dot(self, other)
s.dot(other) = innerproduct(s, other)
dump = not_implemented(*args, **kwds)
dumps = not_implemented(*args, **kwds)
fill = not_implemented(*args, **kwds)
fill_value(self)
Get the current fill value.
filled(self, fill_value=None)
A numeric array with masked values filled. If fill_value is None,
           use fill_value().
 
           If mask is nomask, copy data only if not contiguous.
           Result is always a contiguous, numeric array.
# Is contiguous really necessary now?
flatten = ravel(a)
a as one-dimensional, may share data and mask
getfield = not_implemented(*args, **kwds)
ids(self)
Return the ids of the data and mask areas
iscontiguous(self)
Is the data contiguous?
item(self, *args)
Return Python scalar if possible
itemset(self, *args)
Set Python scalar into array
itemsize(self)
Item size of each data item.
max = _max(a, axis=None, out=None)
mean = new_average(a, axis=None, weights=None, returned=0)
average(a, axis=None, weights=None)
Computes average along indicated axis.
If axis is None, average over the entire array
Inputs can be integer or floating types; result is of type float.
 
If weights are given, result is sum(a*weights,axis=0)/(sum(weights,axis=0)*1.0)
weights must have a's shape or be the 1-d with length the size
of a in the given axis.
 
If returned, return a tuple: the result and the sum of the weights
or count of values. Results will have the same shape.
 
masked values in the weights will be set to 0.0
min = _min(a, axis=None, out=None)
newbyteorder = not_implemented(*args, **kwds)
nonzero(a)
returns the indices of the elements of a which are not zero
and not masked
outer(self, other)
s.outer(other) = outerproduct(s, other)
prod = product(target, axis=None, dtype=None)
ptp = _ptp(a, axis=None, out=None)
put(self, values)
Set the non-masked entries of self to filled(values).
No change to mask
putmask(self, values)
Set the masked entries of self to filled(values).
Mask changed to nomask.
ravel(self)
Return a 1-D view of self.
raw_data(self)
Obsolete; use data property instead.
The raw data; portions may be meaningless.
May be noncontiguous. Expert use only.
raw_mask(self)
Obsolete; use mask property instead.
May be noncontiguous. Expert use only.
repeat = new_repeat(a, repeats, axis=None)
repeat elements of a repeats times along axis
repeats is a sequence of length a.shape[axis]
telling how many times to repeat each element.
reshape(self, *s)
This array reshaped to shape s
resize(a, new_shape)
resize(a, new_shape) returns a new array with the specified shape.
The original array's total size can be any size.
round = round_(...)
Round an array to the given number of decimals.
 
Refer to `around` for full documentation.
 
See Also
--------
around : equivalent function
searchsorted = not_implemented(*args, **kwds)
set_fill_value(self, v=None)
Set the fill value to v. Omit v to restore default.
setfield = not_implemented(*args, **kwds)
setflags = not_implemented(*args, **kwds)
sort = not_implemented(*args, **kwds)
squeeze = _squeeze(self)
std = _std(self, axis=None, dtype=None, out=None)
sum(target, axis=None, dtype=None)
swapaxes = _swapaxes(self, axis1, axis2)
take = new_take(a, indices, axis=None, out=None, mode='raise')
returns selection of items from a.
tofile = not_implemented(*args, **kwds)
tolist(self, fill_value=None)
Convert to list
tostring(self, fill_value=None)
Convert to string
trace(a, offset=0, axis1=0, axis2=1, dtype=None, out=None)
trace(a,offset=0, axis1=0, axis2=1) returns the sum along diagonals
(defined by the last two dimenions) of the array.
transpose(a, axes=None)
reorder dimensions per tuple axes
unmask(self)
Replace the mask by nomask if possible.
unshare_mask(self)
If currently sharing mask, make a copy.
var = _var(self, axis=None, dtype=None, out=None)
view = not_implemented(*args, **kwds)

Data descriptors defined here:
T
get transpose
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)
base
ctypes
ctypes
data
The data, but values at masked locations are meaningless.
dtype
type of the array elements.
flags
flat
Access array in flat form.
imag
Access the imaginary part of the array
imaginary
Access the imaginary part of the array
mask
The mask, may be nomask. Values where mask true are meaningless.
nbytes
ndim
Number of array dimensions.
 
Examples
--------
 
>>> x = np.array([1,2,3])
>>> x.ndim
1
>>> y = np.zeros((2,3,4))
>>> y.ndim
3
real
Access the real part of the array
shape
tuple giving the shape of the array
size
Number of elements in the array.
strides

Data and other attributes defined here:
__array_priority__ = 10.1

 
class _MaskedPrintOption
    One instance of this class, masked_print_option, is created.
 
  Methods defined here:
__init__(self, display)
Create the masked print option object.
__repr__ = __str__(self)
__str__(self)
display(self)
Show what prints for masked values.
enable(self, flag=1)
Set the enabling flag to flag.
enabled(self)
Is the use of the display value enabled?
set_display(self, s)
set_display(s) sets what prints for masked values.

 
class _maximum_operation
    Object to calculate maxima
 
  Methods defined here:
__call__(self, a, b=None)
Execute the call behavior.
__init__(self)
maximum(a, b) or maximum(a)
In one argument case returns the scalar maximum.
outer(self, a, b)
Return the function applied to the outer product of a and b.
reduce(self, target, axis=0)
Reduce target along the given axis.

 
class _minimum_operation
    Object to calculate minima
 
  Methods defined here:
__call__(self, a, b=None)
Execute the call behavior.
__init__(self)
minimum(a, b) or minimum(a)
In one argument case returns the scalar minimum.
outer(self, a, b)
Return the function applied to the outer product of a and b.
reduce(self, target, axis=0)
Reduce target along the given axis.

 
array = class MaskedArray(object)
    Arrays with possibly masked values.
Masked values of 1 exclude the corresponding element from
any computation.
 
Construction:
    x = array(data, dtype=None, copy=True, order=False,
              mask = nomask, fill_value=None)
 
If copy=False, every effort is made not to copy the data:
    If data is a MaskedArray, and argument mask=nomask,
    then the candidate data is data.data and the
    mask used is data.mask. If data is a numeric array,
    it is used as the candidate raw data.
    If dtype is not None and
    is != data.dtype.char then a data copy is required.
    Otherwise, the candidate is used.
 
If a data copy is required, raw data stored is the result of:
numeric.array(data, dtype=dtype.char, copy=copy)
 
If mask is nomask there are no masked values. Otherwise mask must
be convertible to an array of booleans with the same shape as x.
 
fill_value is used to fill in masked values when necessary,
such as when printing and in method/function filled().
The fill_value is not used for computation within this module.
 
  Methods defined here:
__abs__(self)
Return absolute(self)
__add__(self, other)
Return add(self, other)
__and__(self, other)
Return bitwise_and
__array__(self, t=None, context=None)
Special hook for numeric. Converts to numeric if possible.
__array_wrap__(self, array, context=None)
Special hook for ufuncs.
 
Wraps the numpy array and sets the mask according to
context.
__div__(self, other)
Return divide(self, other)
__eq__(self, other)
__float__(self)
Convert self to float.
__floordiv__(self, other)
Return divide(self, other)
__ge__(self, other)
__getitem__(self, i)
Get item described by i. Not a copy as in previous versions.
__gt__(self, other)
__iadd__(self, other)
Add other to self in place.
__idiv__(self, other)
Divide self by other in place.
__imul__(self, other)
Add other to self in place.
__init__(self, data, dtype=None, copy=True, order=False, mask=False, fill_value=None)
array(data, dtype=None, copy=True, order=False, mask=nomask, fill_value=None)
If data already a numeric array, its dtype becomes the default value of dtype.
__int__(self)
Convert self to int.
__isub__(self, other)
Subtract other from self in place.
__le__(self, other)
__len__(self)
Return length of first dimension. This is weird but Python's
slicing behavior depends on it.
__lshift__(self, n)
__lt__(self, other)
__mod__(self, other)
Return remainder(self, other)
__mul__(self, other)
Return multiply(self, other)
__ne__(self, other)
__neg__(self)
Return negative(self)
__nonzero__(self)
returns true if any element is non-zero or masked
__or__(self, other)
Return bitwise_or
__pos__(self)
Return array(self)
__pow__(self, other, third=None)
Return power(self, other, third)
__radd__ = __add__(self, other)
__rand__ = __and__(self, other)
__rdiv__(self, other)
Return divide(other, self)
__repr__(self)
Calculate the repr representation, using masked for fill if
it is enabled. Otherwise fill with fill value.
__rfloordiv__(self, other)
Return divide(other, self)
__rmod__(self, other)
Return remainder(other, self)
__rmul__ = __mul__(self, other)
__ror__ = __or__(self, other)
__rshift__(self, n)
__rsub__(self, other)
Return subtract(other, self)
__rtruediv__(self, other)
Return divide(other, self)
__rxor__ = __xor__(self, other)
__setitem__(self, index, value)
Set item described by index. If value is masked, mask those locations.
__sqrt__(self)
Return sqrt(self)
__str__(self)
Calculate the str representation, using masked for fill if
it is enabled. Otherwise fill with fill value.
__sub__(self, other)
Return subtract(self, other)
__truediv__(self, other)
Return divide(self, other)
__xor__(self, other)
Return bitwise_xor
all = reduce(...)
Reduce target along the given axis with this function.
any = reduce(...)
Reduce target along the given axis with this function.
argmax(x, axis=-1, out=None, fill_value=None)
Treating masked values as if they have the value fill_value,
return sort indices for maximum along given axis.
if fill_value is None, use -get_fill_value(x) if it exists.
Returns a numpy array if x has more than one dimension.
Otherwise, returns a scalar index.
argmin(x, axis=-1, out=None, fill_value=None)
Treating masked values as if they have the value fill_value,
return indices for minimum values along given axis.
if fill_value is None, use get_fill_value(x).
Returns a numpy array if x has more than one dimension.
Otherwise, returns a scalar index.
argsort(x, axis=-1, out=None, fill_value=None)
Treating masked values as if they have the value fill_value,
return sort indices for sorting along given axis.
if fill_value is None, use get_fill_value(x)
Returns a numpy array.
astype(self, tc)
return self as array of given type.
byte_swapped(self)
Returns the raw data field, byte_swapped. Included for consistency
with numeric but doesn't make sense in this context.
byteswap = not_implemented(*args, **kwds)
choose = _choose(self, *args, **kwds)
clip = _clip(self, a_min, a_max, out=None)
compress = _compress(self, cond, axis=None, out=None)
compressed(self)
A 1-D array of all the non-masked data.
conj = conjugate(...)
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)
conjugate(...)
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)
copy = not_implemented(*args, **kwds)
count(self, axis=None)
Count of the non-masked elements in a, or along a certain axis.
cumprod = _cumprod(self, axis=None, dtype=None, out=None)
cumsum = _cumsum(self, axis=None, dtype=None, out=None)
diagonal(a, k=0, axis1=0, axis2=1)
diagonal(a,k=0,axis1=0, axis2=1) = the k'th diagonal of a
dot(self, other)
s.dot(other) = innerproduct(s, other)
dump = not_implemented(*args, **kwds)
dumps = not_implemented(*args, **kwds)
fill = not_implemented(*args, **kwds)
fill_value(self)
Get the current fill value.
filled(self, fill_value=None)
A numeric array with masked values filled. If fill_value is None,
           use fill_value().
 
           If mask is nomask, copy data only if not contiguous.
           Result is always a contiguous, numeric array.
# Is contiguous really necessary now?
flatten = ravel(a)
a as one-dimensional, may share data and mask
getfield = not_implemented(*args, **kwds)
ids(self)
Return the ids of the data and mask areas
iscontiguous(self)
Is the data contiguous?
item(self, *args)
Return Python scalar if possible
itemset(self, *args)
Set Python scalar into array
itemsize(self)
Item size of each data item.
max = _max(a, axis=None, out=None)
mean = new_average(a, axis=None, weights=None, returned=0)
average(a, axis=None, weights=None)
Computes average along indicated axis.
If axis is None, average over the entire array
Inputs can be integer or floating types; result is of type float.
 
If weights are given, result is sum(a*weights,axis=0)/(sum(weights,axis=0)*1.0)
weights must have a's shape or be the 1-d with length the size
of a in the given axis.
 
If returned, return a tuple: the result and the sum of the weights
or count of values. Results will have the same shape.
 
masked values in the weights will be set to 0.0
min = _min(a, axis=None, out=None)
newbyteorder = not_implemented(*args, **kwds)
nonzero(a)
returns the indices of the elements of a which are not zero
and not masked
outer(self, other)
s.outer(other) = outerproduct(s, other)
prod = product(target, axis=None, dtype=None)
ptp = _ptp(a, axis=None, out=None)
put(self, values)
Set the non-masked entries of self to filled(values).
No change to mask
putmask(self, values)
Set the masked entries of self to filled(values).
Mask changed to nomask.
ravel(self)
Return a 1-D view of self.
raw_data(self)
Obsolete; use data property instead.
The raw data; portions may be meaningless.
May be noncontiguous. Expert use only.
raw_mask(self)
Obsolete; use mask property instead.
May be noncontiguous. Expert use only.
repeat = new_repeat(a, repeats, axis=None)
repeat elements of a repeats times along axis
repeats is a sequence of length a.shape[axis]
telling how many times to repeat each element.
reshape(self, *s)
This array reshaped to shape s
resize(a, new_shape)
resize(a, new_shape) returns a new array with the specified shape.
The original array's total size can be any size.
round = round_(...)
Round an array to the given number of decimals.
 
Refer to `around` for full documentation.
 
See Also
--------
around : equivalent function
searchsorted = not_implemented(*args, **kwds)
set_fill_value(self, v=None)
Set the fill value to v. Omit v to restore default.
setfield = not_implemented(*args, **kwds)
setflags = not_implemented(*args, **kwds)
sort = not_implemented(*args, **kwds)
squeeze = _squeeze(self)
std = _std(self, axis=None, dtype=None, out=None)
sum(target, axis=None, dtype=None)
swapaxes = _swapaxes(self, axis1, axis2)
take = new_take(a, indices, axis=None, out=None, mode='raise')
returns selection of items from a.
tofile = not_implemented(*args, **kwds)
tolist(self, fill_value=None)
Convert to list
tostring(self, fill_value=None)
Convert to string
trace(a, offset=0, axis1=0, axis2=1, dtype=None, out=None)
trace(a,offset=0, axis1=0, axis2=1) returns the sum along diagonals
(defined by the last two dimenions) of the array.
transpose(a, axes=None)
reorder dimensions per tuple axes
unmask(self)
Replace the mask by nomask if possible.
unshare_mask(self)
If currently sharing mask, make a copy.
var = _var(self, axis=None, dtype=None, out=None)
view = not_implemented(*args, **kwds)

Data descriptors defined here:
T
get transpose
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)
base
ctypes
ctypes
data
The data, but values at masked locations are meaningless.
dtype
type of the array elements.
flags
flat
Access array in flat form.
imag
Access the imaginary part of the array
imaginary
Access the imaginary part of the array
mask
The mask, may be nomask. Values where mask true are meaningless.
nbytes
ndim
Number of array dimensions.
 
Examples
--------
 
>>> x = np.array([1,2,3])
>>> x.ndim
1
>>> y = np.zeros((2,3,4))
>>> y.ndim
3
real
Access the real part of the array
shape
tuple giving the shape of the array
size
Number of elements in the array.
strides

Data and other attributes defined here:
__array_priority__ = 10.1

 
class domain_check_interval
    domain_check_interval(a,b)(x) = true where x < a or y > b
 
  Methods defined here:
__call__(self, x)
Execute the call behavior.
__init__(self, y1, y2)
domain_check_interval(a,b)(x) = true where x < a or y > b

 
class domain_greater
    domain_greater(v)(x) = true where x <= v
 
  Methods defined here:
__call__(self, x)
Execute the call behavior.
__init__(self, critical_value)
domain_greater(v)(x) = true where x <= v

 
class domain_greater_equal
    domain_greater_equal(v)(x) = true where x < v
 
  Methods defined here:
__call__(self, x)
Execute the call behavior.
__init__(self, critical_value)
domain_greater_equal(v)(x) = true where x < v

 
class domain_safe_divide
     Methods defined here:
__call__(self, a, b)
__init__(self, tolerance=1e-35)

 
class domain_tan
    domain_tan(eps) = true where abs(cos(x)) < eps)
 
  Methods defined here:
__call__(self, x)
Execute the call behavior.
__init__(self, eps)
domain_tan(eps) = true where abs(cos(x)) < eps)

 
class domained_binary_operation
    Binary operations that have a domain, like divide. These are complicated
so they are a separate class. They have no reduce, outer or accumulate.
 
  Methods defined here:
__call__(self, a, b)
Execute the call behavior.
__init__(self, abfunc, domain, fillx=0, filly=0)
abfunc(fillx, filly) must be defined.
abfunc(x, filly) = x for all x to enable reduce.
__str__(self)

 
class masked_binary_operation
     Methods defined here:
__call__(self, a, b, *args, **kwargs)
Execute the call behavior.
__init__(self, abfunc, fillx=0, filly=0)
abfunc(fillx, filly) must be defined.
abfunc(x, filly) = x for all x to enable reduce.
__str__(self)
accumulate(self, target, axis=0)
Accumulate target along axis after filling with y fill value.
outer(self, a, b)
Return the function applied to the outer product of a and b.
reduce(self, target, axis=0, dtype=None)
Reduce target along the given axis with this function.

 
class masked_unary_operation
     Methods defined here:
__call__(self, a, *args, **kwargs)
Execute the call behavior.
__init__(self, aufunc, fill=0, domain=None)
masked_unary_operation(aufunc, fill=0, domain=None)
aufunc(fill) must be defined
self(x) returns aufunc(x)
with masked values where domain(x) is true or getmask(x) is true.
__str__(self)

 
Functions
       
_clip(self, a_min, a_max, out=None)
_cumprod(self, axis=None, dtype=None, out=None)
_cumsum(self, axis=None, dtype=None, out=None)
_ptp(a, axis=None, out=None)
_squeeze(self)
_std(self, axis=None, dtype=None, out=None)
_swapaxes(self, axis1, axis2)
_var(self, axis=None, dtype=None, out=None)
allclose(a, b, fill_value=1, rtol=1.0000000000000001e-05, atol=1e-08)
Returns true if all components of a and b are equal
subject to given tolerances.
If fill_value is 1, masked values considered equal.
If fill_value is 0, masked values considered unequal.
The relative error rtol should be positive and << 1.0
The absolute error atol comes into play for those elements
of b that are very small or zero; it says how small a must be also.
allequal(a, b, fill_value=1)
True if all entries of  a and b are equal, using
fill_value as a truth value where either or both are masked.
alltrue = reduce(self, target, axis=0, dtype=None) method of masked_binary_operation instance
Reduce target along the given axis with this function.
arange(start, stop=None, step=1, dtype=None)
Just like range() except it returns a array whose type can be specified
by the keyword argument dtype.
argmax(x, axis=-1, out=None, fill_value=None)
Treating masked values as if they have the value fill_value,
return sort indices for maximum along given axis.
if fill_value is None, use -get_fill_value(x) if it exists.
Returns a numpy array if x has more than one dimension.
Otherwise, returns a scalar index.
argmin(x, axis=-1, out=None, fill_value=None)
Treating masked values as if they have the value fill_value,
return indices for minimum values along given axis.
if fill_value is None, use get_fill_value(x).
Returns a numpy array if x has more than one dimension.
Otherwise, returns a scalar index.
argsort(x, axis=-1, out=None, fill_value=None)
Treating masked values as if they have the value fill_value,
return sort indices for sorting along given axis.
if fill_value is None, use get_fill_value(x)
Returns a numpy array.
arrayrange = arange(start, stop=None, step=1, dtype=None)
Just like range() except it returns a array whose type can be specified
by the keyword argument dtype.
asarray(data, dtype=None)
asarray(data, dtype) = array(data, dtype, copy=0)
average(a, axis=0, weights=None, returned=0)
choose(indices, t, out=None, mode='raise')
Returns array shaped like indices with elements chosen from t
common_fill_value(a, b)
The common fill_value of a and b, if there is one, or None
compress(condition, x, dimension=-1, out=None)
Select those parts of x for which condition is true.
Masked values in condition are considered false.
concatenate(arrays, axis=0)
Concatenate the arrays along the given axis
count(a, axis=None)
Count of the non-masked elements in a, or along a certain axis.
default_fill_value(obj)
Function to calculate default fill value for an object.
diagonal(a, k=0, axis1=0, axis2=1)
diagonal(a,k=0,axis1=0, axis2=1) = the k'th diagonal of a
dot(a, b)
dot(a,b) returns matrix-multiplication between a and b.  The product-sum
is over the last dimension of a and the second-to-last dimension of b.
Masked values are replaced by zeros. See also innerproduct.
filled(a, value=None)
a as a contiguous numeric array with any masked areas replaced by value
if value is None or the special element "masked", get_fill_value(a)
is used instead.
 
If a is already a contiguous numeric array, a itself is returned.
 
filled(a) can be used to be sure that the result is numeric when
passing an object a to other software ignorant of MA, in particular to
numeric itself.
fromfunction(f, s)
apply f to s to create array as in umath.
fromstring(s, t)
Construct a masked array from a string. Result will have no mask.
get_fill_value(a)
The fill value of a, if it has one; otherwise, the default fill value
for that type.
getmask(a)
Mask of values in a; could be nomask.
Returns nomask if a is not a masked array.
To get an array for sure use getmaskarray.
getmaskarray(a)
Mask of values in a; an array of zeros if mask is nomask
or not a masked array, and is a byte-sized integer.
Do not try to add up entries, for example.
identity(n)
identity(n) returns the identity matrix of shape n x n.
indices(dimensions, dtype=None)
indices(dimensions,dtype=None) returns an array representing a grid
of indices with row-only, and column-only variation.
inner(a, b)
inner(a,b) returns the dot product of two arrays, which has
shape a.shape[:-1] + b.shape[:-1] with elements computed by summing the
product of the elements from the last dimensions of a and b.
Masked elements are replace by zeros.
innerproduct = inner(a, b)
inner(a,b) returns the dot product of two arrays, which has
shape a.shape[:-1] + b.shape[:-1] with elements computed by summing the
product of the elements from the last dimensions of a and b.
Masked elements are replace by zeros.
isMA = isMaskedArray(x)
Is x a masked array, that is, an instance of MaskedArray?
isMaskedArray(x)
Is x a masked array, that is, an instance of MaskedArray?
is_mask(m)
Is m a legal mask? Does not check contents, only type.
isarray = isMaskedArray(x)
Is x a masked array, that is, an instance of MaskedArray?
left_shift(a, n)
Left shift n bits
make_mask(m, copy=0, flag=0)
make_mask(m, copy=0, flag=0)
return m as a mask, creating a copy if necessary or requested.
Can accept any sequence of integers or nomask. Does not check
that contents must be 0s and 1s.
if flag, return nomask if m contains no true elements.
make_mask_none(s)
Return a mask of all zeros of shape s.
mask_or(m1, m2)
Logical or of the mask candidates m1 and m2, treating nomask as false.
Result may equal m1 or m2 if the other is nomask.
masked_array(a, mask=False, fill_value=None)
masked_array(a, mask=nomask) =
array(a, mask=mask, copy=0, fill_value=fill_value)
masked_equal(x, value, copy=1)
masked_equal(x, value) = x masked where x == value
For floating point consider masked_values(x, value) instead.
masked_greater(x, value, copy=1)
masked_greater(x, value) = x masked where x > value
masked_greater_equal(x, value, copy=1)
masked_greater_equal(x, value) = x masked where x >= value
masked_inside(x, v1, v2, copy=1)
x with mask of all values of x that are inside [v1,v2]
v1 and v2 can be given in either order.
masked_less(x, value, copy=1)
masked_less(x, value) = x masked where x < value
masked_less_equal(x, value, copy=1)
masked_less_equal(x, value) = x masked where x <= value
masked_not_equal(x, value, copy=1)
masked_not_equal(x, value) = x masked where x != value
masked_object(data, value, copy=1)
Create array masked where exactly data equal to value
masked_outside(x, v1, v2, copy=1)
x with mask of all values of x that are outside [v1,v2]
v1 and v2 can be given in either order.
masked_values(data, value, rtol=1.0000000000000001e-05, atol=1e-08, copy=1)
masked_values(data, value, rtol=1.e-5, atol=1.e-8)
Create a masked array; mask is nomask if possible.
If copy==0, and otherwise possible, result
may share data values with original array.
Let d = filled(data, value). Returns d
masked where abs(data-value)<= atol + rtol * abs(value)
if d is of a floating point type. Otherwise returns
masked_object(d, value, copy)
masked_where(condition, x, copy=1)
Return x as an array masked where condition is true.
Also masked where x or condition masked.
maximum_fill_value(obj)
Function to calculate default fill value suitable for taking maxima.
minimum_fill_value(obj)
Function to calculate default fill value suitable for taking minima.
new_average(a, axis=None, weights=None, returned=0)
average(a, axis=None, weights=None)
Computes average along indicated axis.
If axis is None, average over the entire array
Inputs can be integer or floating types; result is of type float.
 
If weights are given, result is sum(a*weights,axis=0)/(sum(weights,axis=0)*1.0)
weights must have a's shape or be the 1-d with length the size
of a in the given axis.
 
If returned, return a tuple: the result and the sum of the weights
or count of values. Results will have the same shape.
 
masked values in the weights will be set to 0.0
new_repeat(a, repeats, axis=None)
repeat elements of a repeats times along axis
repeats is a sequence of length a.shape[axis]
telling how many times to repeat each element.
new_take(a, indices, axis=None, out=None, mode='raise')
returns selection of items from a.
nonzero(a)
returns the indices of the elements of a which are not zero
and not masked
ones(shape, dtype=<type 'float'>)
ones(n, dtype=float) =
an array of all ones of the given length or shape.
outer(a, b)
outer(a,b) = {a[i]*b[j]}, has shape (len(a),len(b))
outerproduct = outer(a, b)
outer(a,b) = {a[i]*b[j]}, has shape (len(a),len(b))
power(a, b, third=None)
a**b
product(target, axis=None, dtype=None)
put(a, indices, values, mode='raise')
sets storage-indexed locations to corresponding values.
 
Values and indices are filled if necessary.
putmask(a, mask, values)
putmask(a, mask, values) sets a where mask is true.
rank(object)
ravel(a)
a as one-dimensional, may share data and mask
repeat(a, repeats, axis=0)
reshape(a, *newshape)
Copy of a with a new shape.
resize(a, new_shape)
resize(a, new_shape) returns a new array with the specified shape.
The original array's total size can be any size.
right_shift(a, n)
Right shift n bits
set_fill_value(a, fill_value)
Set fill value of a if it is a masked array.
shape(object)
size(object, axis=None)
sometrue = reduce(self, target, axis=0, dtype=None) method of masked_binary_operation instance
Reduce target along the given axis with this function.
sort(x, axis=-1, fill_value=None)
If x does not have a mask, return a masked array formed from the
result of numeric.sort(x, axis).
Otherwise, fill x with fill_value. Sort it.
Set a mask where the result is equal to fill_value.
Note that this may have unintended consequences if the data contains the
fill value at a non-masked site.
 
If fill_value is not given the default fill value for x's type will be
used.
sum(target, axis=None, dtype=None)
swapaxes(a, axis1, axis2)
take(a, indices, axis=0)
trace(a, offset=0, axis1=0, axis2=1, dtype=None, out=None)
trace(a,offset=0, axis1=0, axis2=1) returns the sum along diagonals
(defined by the last two dimenions) of the array.
transpose(a, axes=None)
reorder dimensions per tuple axes
where(condition, x, y)
where(condition, x, y) is x where condition is nonzero, y otherwise.
condition must be convertible to an integer array.
Answer is always the shape of condition.
The type depends on x and y. It is integer if both x and y are
the value masked.
zeros(shape, dtype=<type 'float'>)
zeros(n, dtype=float) =
an array of all zeros of the given length or shape.

 
Data
        __file__ = '/usr/lib/python2.6/dist-packages/numpy/oldnumeric/ma.pyc'
__name__ = 'numpy.oldnumeric.ma'
__package__ = 'numpy.oldnumeric'
absolute = <numpy.oldnumeric.ma.masked_unary_operation instance at 0x713e290>
add = <numpy.oldnumeric.ma.masked_binary_operation instance at 0x713e488>
arccos = <numpy.oldnumeric.ma.masked_unary_operation instance at 0x7129f80>
arccosh = <numpy.oldnumeric.ma.masked_unary_operation instance at 0x713e0e0>
arcsin = <numpy.oldnumeric.ma.masked_unary_operation instance at 0x7129ef0>
arcsinh = <numpy.oldnumeric.ma.masked_unary_operation instance at 0x713e050>
arctan = <numpy.oldnumeric.ma.masked_unary_operation instance at 0x7129fc8>
arctan2 = <numpy.oldnumeric.ma.masked_binary_operation instance at 0x713e878>
arctanh = <numpy.oldnumeric.ma.masked_unary_operation instance at 0x713e170>
around = <numpy.oldnumeric.ma.masked_unary_operation instance at 0x713e368>
bitwise_and = <numpy.oldnumeric.ma.masked_binary_operation instance at 0x713eb90>
bitwise_or = <numpy.oldnumeric.ma.masked_binary_operation instance at 0x713ebd8>
bitwise_xor = <numpy.oldnumeric.ma.masked_binary_operation instance at 0x713ec20>
ceil = <numpy.oldnumeric.ma.masked_unary_operation instance at 0x713e3f8>
conjugate = <numpy.oldnumeric.ma.masked_unary_operation instance at 0x7129d40>
cos = <numpy.oldnumeric.ma.masked_unary_operation instance at 0x7129dd0>
cosh = <numpy.oldnumeric.ma.masked_unary_operation instance at 0x713e200>
default_character_fill_value = '-'
default_complex_fill_value = (1e+20+0j)
default_integer_fill_value = 999999
default_object_fill_value = '?'
default_real_fill_value = 1e+20
divide = <numpy.oldnumeric.ma.domained_binary_operation instance at 0x713e5a8>
divide_tolerance = 1e-35
equal = <numpy.oldnumeric.ma.masked_binary_operation instance at 0x713e8c0>
exp = <numpy.oldnumeric.ma.masked_unary_operation instance at 0x7129cf8>
fabs = <numpy.oldnumeric.ma.masked_unary_operation instance at 0x713e2d8>
floor = <numpy.oldnumeric.ma.masked_unary_operation instance at 0x713e3b0>
floor_divide = <numpy.oldnumeric.ma.domained_binary_operation instance at 0x713e6c8>
fmod = <numpy.oldnumeric.ma.domained_binary_operation instance at 0x713e7e8>
greater = <numpy.oldnumeric.ma.masked_binary_operation instance at 0x713ea28>
greater_equal = <numpy.oldnumeric.ma.masked_binary_operation instance at 0x713e998>
hypot = <numpy.oldnumeric.ma.masked_binary_operation instance at 0x713e830>
less = <numpy.oldnumeric.ma.masked_binary_operation instance at 0x713e9e0>
less_equal = <numpy.oldnumeric.ma.masked_binary_operation instance at 0x713e950>
log = <numpy.oldnumeric.ma.masked_unary_operation instance at 0x7129c20>
log10 = <numpy.oldnumeric.ma.masked_unary_operation instance at 0x7129cb0>
logical_and = <numpy.oldnumeric.ma.masked_binary_operation instance at 0x713ea70>
logical_not = <numpy.oldnumeric.ma.masked_unary_operation instance at 0x713e440>
logical_or = <numpy.oldnumeric.ma.masked_binary_operation instance at 0x713eb00>
logical_xor = <numpy.oldnumeric.ma.masked_binary_operation instance at 0x713eb48>
masked = array(data = 999999, mask = True, fill_value=999999)
masked_print_option = --
maximum = <numpy.oldnumeric.ma._maximum_operation instance at 0x713ed40>
minimum = <numpy.oldnumeric.ma._minimum_operation instance at 0x713ecf8>
multiply = <numpy.oldnumeric.ma.masked_binary_operation instance at 0x713e518>
negative = <numpy.oldnumeric.ma.masked_unary_operation instance at 0x713e320>
nomask = False
not_equal = <numpy.oldnumeric.ma.masked_binary_operation instance at 0x713e908>
remainder = <numpy.oldnumeric.ma.domained_binary_operation instance at 0x713e758>
sin = <numpy.oldnumeric.ma.masked_unary_operation instance at 0x7129d88>
sinh = <numpy.oldnumeric.ma.masked_unary_operation instance at 0x713e1b8>
sqrt = <numpy.oldnumeric.ma.masked_unary_operation instance at 0x7129b90>
subtract = <numpy.oldnumeric.ma.masked_binary_operation instance at 0x713e4d0>
tan = <numpy.oldnumeric.ma.masked_unary_operation instance at 0x7129e60>
tanh = <numpy.oldnumeric.ma.masked_unary_operation instance at 0x713e248>
true_divide = <numpy.oldnumeric.ma.domained_binary_operation instance at 0x713e638>
ufunc_domain = {<function round_ at 0x22bda28>: None, <ufunc 'cos'>: None, <ufunc 'add'>: None, <ufunc 'arcsinh'>: None, <ufunc 'bitwise_and'>: None, <ufunc 'arctanh'>: <numpy.oldnumeric.ma.domain_check_interval instance at 0x713e128>, <ufunc 'arctan'>: None, <ufunc 'arctan2'>: None, <ufunc 'conjugate'>: None, <ufunc 'bitwise_or'>: None, ...}
ufunc_fills = {<function round_ at 0x22bda28>: (0,), <ufunc 'cos'>: (0,), <ufunc 'add'>: (0, 0), <ufunc 'arcsinh'>: (0,), <ufunc 'bitwise_and'>: (0, 0), <ufunc 'arctanh'>: (0.0,), <ufunc 'arctan'>: (0,), <ufunc 'arctan2'>: (0.0, 1.0), <ufunc 'conjugate'>: (0,), <ufunc 'bitwise_or'>: (0, 0), ...}