numarray.records.RecArray

Package numarray :: Module records :: Class RecArray

[show private | hide private]

Type RecArray

object --+        
         |        
  _ndarray --+    
             |    
       NDArray --+
                 |
                RecArray

Known Subclasses:: NestedRecArray

Record Array Class

Method Summary
	`__init__(self, buffer, formats, shape, names, byteoffset, bytestride, byteorder, aligned)`
	`__add__(self, other)` Add two RecArray objects in a row wise manner
	`__getstate__(self)` returns pickled state dictionary for RecArray
	`__repr__(self)`
	`__setstate__(self, state)` restores state of NDArray after unpickling.
	`__str__(self)`
	`byteswap(self)` Byteswap data in place and change the _byteorder attribute.
	`field(self, fieldName)` get the field data as a numeric array
	`getbyteorder(self)`
	`info(self)` info() prints out key attributes of a record array.
	`reshape(*value)`
	`togglebyteorder(self)` reverses the state of the _byteorder attribute: little <-> big.
	`view(self)`
	`_byteswap(self)` Byteswap the data in place.
	`_fieldNames(self, names)` convert input field names into a list and assign to the _names attribute
	`_get_fields(self)` Get a dictionary of fields as numeric arrays.
	`_getitem(self, offset)`
	`_parseFormats(self, formats)` Parse the field formats
	`_setitem(self, offset, value)`
Inherited from NDArray
	`__copy__(self)` support for copy.copy()
	`__deepcopy__(self, memo)` support for copy.deepcopy()
	`__nonzero__(self)`
	`__reduce__(self)` __reduce__ returns the pickling "reduction tuple" for an NDArray.
	`astype(self, type)`
	`copy(self)` Return a new array with the same shape and type, but a copy of the data
	`factory(self, args, *keys)` factory(...) calls the array(...) factory function defined in the source module where the class of 'self' was defined.
	`getflat(self)`
	`getrank(self)`
	`getshape(self)`
	`is_c_array(self)` is_c_array() returns 1 iff the array is aligned and contiguous, and returns 0 otherwise.
	`itemsize(self)` Size (in bytes) of an array element
	`nonzero(self)`
	`put(self, indices, *keywords)`
	`ravel(self)` ravel(self) setshapes 'self' into an equivalent 1D array.
	`repeat(self, repeats, axis)` repeat() returns a new array with each element 'a[i]' repeated 'r[i]' times.
	`resize(self, shape, *args)` resize() shrinks/grows 'self' to new 'shape', possibly replacing the underlying buffer object.
	`setflat(self, flat)`
	`setshape(self, shape, *args)` Change array shape in place.
	`take(self, indices, *keywords)`
	`tofile(self, file)` Write the array as a binary image to a file.
	`tostring(self)` Return a string with a binary copy of the array
	`transpose(self, axes)` transpose() re-shapes the array by permuting it's dimensions as specified by 'axes'.
	`_arrayIndexing(self, key, value)`
	`_broadcast(self, arr)` Return broadcast view of arr, else return None.
	`_clone(self, shape)`
	`_copyFrom(self, arr)` Copy elements from another array.
	`_dualbroadcast(self, arr)` Return broadcast views both self and arr, else return (None,None).
	`_fix_pt_indices(self, indices)`
	`_isSlice(self, key)`
	`_put(self, indices, values, **keywds)`
	`_stridesFromShape(self)` Compute the strides from shape for a contiguous array
	`_take(self, indices, **keywds)`
	`_tofileByBlocks(self, file, dims, indexlevel, blockingparameters)` Write the array to a file repeatedly in blocks
Inherited from _ndarray
	`__delitem__(x, y)` x.__delitem__(y) <==> del x[y]
	`__getitem__(x, y)` x.__getitem__(y) <==> x[y]
	`__len__(x)` x.__len__() <==> len(x)
	`__new__(T, S, ...)` T.__new__(S, ...) -> a new object with type S, a subtype of T
	`__setitem__(x, i, y)` x.__setitem__(i, y) <==> x[i]=y
byte offset of indices within array	`_getByteOffset(indices)` _getByteOffset(indices) -> byte offset of indices within array
None	`_putter(axis1, axis2)` _putter(axis1, axis2) -> None
	`_simpleIndexing(...)` _simpleIndexing(key, value=None) gets or sets for integer sequence key
None	`_taker(axis1, axis2)` _taker(axis1, axis2) -> None
	`_universalIndexing(...)` _universalIndexing(key, value=None) gets(value=None) or sets(value!=None) at key
1 if array is fortran-contiguous, 0 otherwise.	`is_fortran_contiguous()` is_fortran_contiguous() -> 1 if array is fortran-contiguous, 0 otherwise.
1 if array is aligned, 0 otherwise.	`isaligned()` isaligned() -> 1 if array is aligned, 0 otherwise.
1 if array is contiguous, 0 otherwise.	`iscontiguous()` iscontiguous() -> 1 if array is contiguous, 0 otherwise.
total number of elements in array.	`nelements()` nelements() -> total number of elements in array.
total number of elements in array.	`size()` nelements() -> total number of elements in array.
None	`swapaxes(axis1, axis2)` swapaxes(axis1, axis2) -> None
array converted to nested list of scalars.	`tolist()` tolist() -> array converted to nested list of scalars.
Inherited from object
	`__delattr__(...)` x.__delattr__('name') <==> del x.name
	`__getattribute__(...)` x.__getattribute__('name') <==> x.name
	`__hash__(x)` x.__hash__() <==> hash(x)
	`__reduce_ex__(...)` helper for pickle
	`__setattr__(...)` x.__setattr__('name', value) <==> x.name = value

Property Summary
Inherited from NDArray
	`flat`: access to array as 1D
	`shape`: tuple of array dimensions

Class Variable Summary
Inherited from _ndarray
`getset_descriptor`	`_aligned` = `<attribute '_aligned' of '_ndarray._ndarray' ...`
`getset_descriptor`	`_byteoffset` = `<attribute '_byteoffset' of '_ndarray._nda...`
`getset_descriptor`	`_bytestride` = `<attribute '_bytestride' of '_ndarray._nda...`
`getset_descriptor`	`_contiguous` = `<attribute '_contiguous' of '_ndarray._nda...`
`getset_descriptor`	`_data` = `<attribute '_data' of '_ndarray._ndarray' object...`
`getset_descriptor`	`_itemsize` = `<attribute '_itemsize' of '_ndarray._ndarray...`
`getset_descriptor`	`_shape` = `<attribute '_shape' of '_ndarray._ndarray' obje...`
`getset_descriptor`	`_strides` = `<attribute '_strides' of '_ndarray._ndarray' ...`
`getset_descriptor`	`flags` = `<attribute 'flags' of '_ndarray._ndarray' object...`
`getset_descriptor`	`rank` = `<attribute 'rank' of '_ndarray._ndarray' objects>`

Method Details

add(self, other)
(Addition operator)

Add two RecArray objects in a row wise manner

getstate(self)

returns pickled state dictionary for RecArray

Overrides:: numarray.generic.NDArray.__getstate__

setstate(self, state)

restores state of NDArray after unpickling.

Overrides:: numarray.generic.NDArray.__setstate__ (inherited documentation)

byteswap(self)

Byteswap data in place and change the _byteorder attribute.

field(self, fieldName)

get the field data as a numeric array

info(self)

info() prints out key attributes of a record array.

Overrides:: numarray.generic.NDArray.info

togglebyteorder(self)

reverses the state of the _byteorder attribute: little <-> big.

_byteswap(self)

Byteswap the data in place. Does *not* change _byteorder.

_fieldNames(self, names=None)

convert input field names into a list and assign to the _names attribute

_get_fields(self)

Get a dictionary of fields as numeric arrays.

_parseFormats(self, formats)

Parse the field formats

Generated by Epydoc 2.1 on Thu Apr 21 13:11:50 2005

http://epydoc.sf.net