Version 1.0b1 API Documentation generated by Endo 2006-08-14

Variables

• MaskType

  MaskType = bool_
  
  

• absolute

  absolute = masked_unary_operation(umath.absolute)
  
  

• add

  add = masked_binary_operation(umath.add)
  
  

• alltrue

  alltrue = masked_binary_operation(umath.logical_and, 1, 1).reduce
  
  

• arccos

  arccos = masked_unary_operation(umath.arccos, 0.0, domain_check_interval(-Const(1.0), 1.0))
  
  

• arccosh

  arccosh = masked_unary_operation(umath.arccosh, 1.0, domain_greater_equal(1.0))
  
  

• arcsin

  arcsin = masked_unary_operation(umath.arcsin, 0.0, domain_check_interval(-Const(1.0), 1.0))
  
  

• arcsinh

  Missing from numeric

  arcsinh = masked_unary_operation(umath.arcsinh)
  
  

• arctan

  arctan = masked_unary_operation(umath.arctan)
  
  

• arctan2

  arctan2 = masked_binary_operation(umath.arctan2, 0.0, 1.0)
  
  

• arctanh

  arctanh = masked_unary_operation(umath.arctanh, 0.0, domain_check_interval((-Const(1.0) + 1.0000000000000001e-015), (1.0 - 1.0000000000000001e-015)))
  
  

• around

  around = masked_unary_operation(fromnumeric.round_)
  
  

• array

  array = MaskedArray
  
  

• arrayrange

  arrayrange = arange
  
  

• bitwise_and

  bitwise_and = masked_binary_operation(umath.bitwise_and)
  
  

• bitwise_or

  bitwise_or = masked_binary_operation(umath.bitwise_or)
  
  

• bitwise_xor

  bitwise_xor = masked_binary_operation(umath.bitwise_xor)
  
  

• ceil

  ceil = masked_unary_operation(umath.ceil)
  
  

• conjugate

  conjugate = masked_unary_operation(umath.conjugate)
  
  

• cos

  cos = masked_unary_operation(umath.cos)
  
  

• cosh

  cosh = masked_unary_operation(umath.cosh)
  
  

• default_character_fill_value

  default_character_fill_value = '-'
  
  

• default_complex_fill_value

  default_complex_fill_value = (1e+020 + 0j)
  
  

• default_integer_fill_value

  default_integer_fill_value = 999999
  
  

• default_object_fill_value

  default_object_fill_value = '?'
  
  

• default_real_fill_value

  Use single element arrays or scalars.

  default_real_fill_value = 1e+020
  
  

• divide

  divide = domained_binary_operation(umath.divide, domain_safe_divide(), 0, 1)
  
  

• divide_tolerance

  divide_tolerance = 1e-035
  
  

• equal

  equal = masked_binary_operation(umath.equal)
  
  

• exp

  exp = masked_unary_operation(umath.exp)
  
  

• fabs

  fabs = masked_unary_operation(umath.fabs)
  
  

• floor

  floor = masked_unary_operation(umath.floor)
  
  

• floor_divide

  floor_divide = domained_binary_operation(umath.floor_divide, domain_safe_divide(), 0, 1)
  
  

• fmod

  fmod = domained_binary_operation(umath.fmod, domain_safe_divide(), 0, 1)
  
  

• greater

  greater = masked_binary_operation(umath.greater)
  
  

• greater_equal

  greater_equal = masked_binary_operation(umath.greater_equal)
  
  

• hypot

  hypot = masked_binary_operation(umath.hypot)
  
  

• innerproduct

  innerproduct = inner
  
  

• isMA

  isMA = isMaskedArray
  
  

• isarray

  isarray = isMaskedArray
  
  

• less

  less = masked_binary_operation(umath.less)
  
  

• less_equal

  less_equal = masked_binary_operation(umath.less_equal)
  
  

• log

  log = masked_unary_operation(umath.log, 1.0, domain_greater(0.0))
  
  

• log10

  log10 = masked_unary_operation(umath.log10, 1.0, domain_greater(0.0))
  
  

• logical_and

  logical_and = masked_binary_operation(umath.logical_and)
  
  

• logical_not

  logical_not = masked_unary_operation(umath.logical_not)
  
  

• logical_or

  logical_or = masked_binary_operation(umath.logical_or)
  
  

• logical_xor

  logical_xor = masked_binary_operation(umath.logical_xor)
  
  

• masked

  masked = MaskedArray(0, int, mask = 1)
  
  

• masked_print_option

  if you single index into a masked location you get this object.

  masked_print_option = _MaskedPrintOption('--')
  
  

• maximum

  maximum = _maximum_operation()
  
  

• minimum

  minimum = _minimum_operation()
  
  

• multiply

  multiply = masked_binary_operation(umath.multiply, 1, 1)
  
  

• negative

  negative = masked_unary_operation(umath.negative)
  
  

• nomask

  nomask = MaskType(0)
  
  

• not_equal

  not_equal = masked_binary_operation(umath.not_equal)
  
  

• outerproduct

  outerproduct = outer
  
  

• product

  product = multiply.reduce
  
  

• remainder

  remainder = domained_binary_operation(umath.remainder, domain_safe_divide(), 0, 1)
  
  

• sin

  sin = masked_unary_operation(umath.sin)
  
  

• sinh

  sinh = masked_unary_operation(umath.sinh)
  
  

• sometrue

  sometrue = logical_or.reduce
  
  

• sqrt

  sqrt = masked_unary_operation(umath.sqrt, 0.0, domain_greater_equal(0.0))
  
  

• subtract

  subtract = masked_binary_operation(umath.subtract)
  
  

• sum

  sum = add.reduce
  
  

• tan

  tan = masked_unary_operation(umath.tan, 0.0, domain_tan(1e-035))
  
  

• tanh

  tanh = masked_unary_operation(umath.tanh)
  
  

• true_divide

  true_divide = domained_binary_operation(umath.true_divide, domain_safe_divide(), 0, 1)
  
  

• ufunc_domain

  Ufunc domain lookup for __array_wrap__

  ufunc_domain = {  }
  
  

• ufunc_fills

  Ufunc fills lookup for __array__

  ufunc_fills = {  }
  
  

Classes

• MAError
• MaskedArray - Arrays with possibly masked values.
• domain_check_interval - domain_check_interval(a,b)(x) = true where x < a or y > b
• domain_greater - domain_greater(v)(x) = true where x <= v
• domain_greater_equal - domain_greater_equal(v)(x) = true where x < v
• domain_safe_divide
• domain_tan - domain_tan(eps) = true where abs(cos(x)) < eps)
• domained_binary_operation - Binary operations that have a domain, like divide. These are complicated
• masked_binary_operation
• masked_unary_operation

Function summary

• allclose(a, b, fill_value = 1, rtol = 1.0000000000000001e-005, atol = 1e-008)
• allequal(a, b, fill_value = 1)
• arange(start, stop = None, step = 1, dtype = None)
• argmax(x, axis = -Const(1), fill_value = None)
• argmin(x, axis = -Const(1), fill_value = None)
• argsort(x, axis = -Const(1), fill_value = None)
• asarray(data, dtype = None)
• average(a, axis = 0, weights = None, returned = 0)
• choose(indices, t)
• common_fill_value(a, b)
• compress(condition, x, dimension = -Const(1))
• concatenate(arrays, axis = 0)
• count(a, axis = None)
• default_fill_value(obj)
• diagonal(a, k = 0, axis1 = 0, axis2 = 1)
• dot(a, b)
• filled(a, value = None)
• fromfunction(f, s)
• fromstring(s, t)
• get_fill_value(a)
• getmask(a)
• getmaskarray(a)
• identity(n)
• indices(dimensions, dtype = None)
• inner(a, b)
• isMaskedArray(x)
• is_mask(m)
• left_shift(a, n)
• make_mask(m, copy = 0, flag = 0)
• make_mask_none(s)
• mask_or(m1, m2)
• masked_array(a, mask = nomask, fill_value = None)
• masked_equal(x, value, copy = 1)
• masked_greater(x, value, copy = 1)
• masked_greater_equal(x, value, copy = 1)
• masked_inside(x, v1, v2, copy = 1)
• masked_less(x, value, copy = 1)
• masked_less_equal(x, value, copy = 1)
• masked_not_equal(x, value, copy = 1)
• masked_object(data, value, copy = 1)
• masked_outside(x, v1, v2, copy = 1)
• masked_values(data, value, rtol = 1.0000000000000001e-005, atol = 1e-008, copy = 1)
• masked_where(condition, x, copy = 1)
• maximum_fill_value(obj)
• minimum_fill_value(obj)
• nonzero(a)
• not_implemented(args, kwds)
• ones(shape, dtype = int)
• outer(a, b)
• power(a, b, third = None)
• put(a, indices, values)
• putmask(a, mask, values)
• rank(object)
• ravel(a)
• repeat(a, repeats, axis = 0)
• reshape(a, newshape)
• resize(a, new_shape)
• right_shift(a, n)
• set_fill_value(a, fill_value)
• shape(object)
• size(object, axis = None)
• sort(x, axis = -Const(1), fill_value = None)
• swapaxes(a, axis1, axis2)
• take(a, indices, axis = 0)
• trace(a, offset = 0, axis1 = 0, axis2 = 1, dtype = None)
• transpose(a, axes = None)
• where(condition, x, y)
• zeros(shape, dtype = int)

Functions

• allclose(a, b, fill_value = 1, rtol = 1.0000000000000001e-005, atol = 1e-008)

  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.

• 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 = -Const(1), 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 = -Const(1), 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 = -Const(1), 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.

• asarray(data, dtype = None)

  asarray(data, dtype) = array(data, dtype, copy=0)

• average(a, axis = 0, weights = None, returned = 0)

  average(a, axis=0, 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)/(sum(weights)*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

• choose(indices, t)

  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 = -Const(1))

  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.

• 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.

• 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 = nomask, 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-005, atol = 1e-008, 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.

• nonzero(a)

  returns the indices of the elements of a which are not zero and not masked

  a must be 1d

• not_implemented(args, kwds)
• ones(shape, dtype = int)

  ones(n, dtype=int) = 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))

• power(a, b, third = None)

  a**b

• put(a, indices, values)

  put(a, indices, values) 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)

  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(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)
• sort(x, axis = -Const(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.

• swapaxes(a, axis1, axis2)
• take(a, indices, axis = 0)

  take(a, indices, axis=0) returns selection of items from a.

• trace(a, offset = 0, axis1 = 0, axis2 = 1, dtype = 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)

  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 = int)

  zeros(n, dtype=int) = an array of all zeros of the given length or shape.

Imported names