NumPy doc (五)
来源:互联网 发布:来疯直播怎么样 知乎 编辑:程序博客网 时间:2024/06/10 03:47
class ndindex(__builtin__.object) | An N-dimensional iterator object to index arrays. | | Given the shape of an array, an `ndindex` instance iterates over | the N-dimensional index of the array. At each iteration a tuple | of indices is returned, the last dimension is iterated over first. | | Parameters | ---------- | `*args` : ints | The size of each dimension of the array. | | See Also | -------- | ndenumerate, flatiter | | Examples | -------- | >>> for index in np.ndindex(3, 2, 1): | ... print index | (0, 0, 0) | (0, 1, 0) | (1, 0, 0) | (1, 1, 0) | (2, 0, 0) | (2, 1, 0) | | Methods defined here: | | __init__(self, *shape) | | __iter__(self) | | __next__(self) | Standard iterator method, updates the index and returns the index | tuple. | | Returns | ------- | val : tuple of ints | Returns a tuple containing the indices of the current | iteration. | | ndincr(self) | Increment the multi-dimensional index by one. | | This method is for backward compatibility only: do not use. | | next = __next__(self) | | ---------------------------------------------------------------------- | Data descriptors defined here: | | __dict__ | dictionary for instance variables (if defined) | | __weakref__ | list of weak references to the object (if defined) class nditer(__builtin__.object) | Efficient multi-dimensional iterator object to iterate over arrays. | To get started using this object, see the | :ref:`introductory guide to array iteration <arrays.nditer>`. | | Parameters | ---------- | op : ndarray or sequence of array_like | The array(s) to iterate over. | flags : sequence of str, optional | Flags to control the behavior of the iterator. | | * "buffered" enables buffering when required. | * "c_index" causes a C-order index to be tracked. | * "f_index" causes a Fortran-order index to be tracked. | * "multi_index" causes a multi-index, or a tuple of indices | with one per iteration dimension, to be tracked. | * "common_dtype" causes all the operands to be converted to | a common data type, with copying or buffering as necessary. | * "delay_bufalloc" delays allocation of the buffers until | a reset() call is made. Allows "allocate" operands to | be initialized before their values are copied into the buffers. | * "external_loop" causes the `values` given to be | one-dimensional arrays with multiple values instead of | zero-dimensional arrays. | * "grow_inner" allows the `value` array sizes to be made | larger than the buffer size when both "buffered" and | "external_loop" is used. | * "ranged" allows the iterator to be restricted to a sub-range | of the iterindex values. | * "refs_ok" enables iteration of reference types, such as | object arrays. | * "reduce_ok" enables iteration of "readwrite" operands | which are broadcasted, also known as reduction operands. | * "zerosize_ok" allows `itersize` to be zero. | op_flags : list of list of str, optional | This is a list of flags for each operand. At minimum, one of | "readonly", "readwrite", or "writeonly" must be specified. | | * "readonly" indicates the operand will only be read from. | * "readwrite" indicates the operand will be read from and written to. | * "writeonly" indicates the operand will only be written to. | * "no_broadcast" prevents the operand from being broadcasted. | * "contig" forces the operand data to be contiguous. | * "aligned" forces the operand data to be aligned. | * "nbo" forces the operand data to be in native byte order. | * "copy" allows a temporary read-only copy if required. | * "updateifcopy" allows a temporary read-write copy if required. | * "allocate" causes the array to be allocated if it is None | in the `op` parameter. | * "no_subtype" prevents an "allocate" operand from using a subtype. | * "arraymask" indicates that this operand is the mask to use | for selecting elements when writing to operands with the | 'writemasked' flag set. The iterator does not enforce this, | but when writing from a buffer back to the array, it only | copies those elements indicated by this mask. | * 'writemasked' indicates that only elements where the chosen | 'arraymask' operand is True will be written to. | op_dtypes : dtype or tuple of dtype(s), optional | The required data type(s) of the operands. If copying or buffering | is enabled, the data will be converted to/from their original types. | order : {'C', 'F', 'A', 'K'}, optional | Controls the iteration order. 'C' means C order, 'F' means | Fortran order, 'A' means 'F' order if all the arrays are Fortran | contiguous, 'C' order otherwise, and 'K' means as close to the | order the array elements appear in memory as possible. This also | affects the element memory order of "allocate" operands, as they | are allocated to be compatible with iteration order. | Default is 'K'. | casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional | Controls what kind of data casting may occur when making a copy | or buffering. Setting this to 'unsafe' is not recommended, | as it can adversely affect accumulations. | | * 'no' means the data types should not be cast at all. | * 'equiv' means only byte-order changes are allowed. | * 'safe' means only casts which can preserve values are allowed. | * 'same_kind' means only safe casts or casts within a kind, | like float64 to float32, are allowed. | * 'unsafe' means any data conversions may be done. | op_axes : list of list of ints, optional | If provided, is a list of ints or None for each operands. | The list of axes for an operand is a mapping from the dimensions | of the iterator to the dimensions of the operand. A value of | -1 can be placed for entries, causing that dimension to be | treated as "newaxis". | itershape : tuple of ints, optional | The desired shape of the iterator. This allows "allocate" operands | with a dimension mapped by op_axes not corresponding to a dimension | of a different operand to get a value not equal to 1 for that | dimension. | buffersize : int, optional | When buffering is enabled, controls the size of the temporary | buffers. Set to 0 for the default value. | | Attributes | ---------- | dtypes : tuple of dtype(s) | The data types of the values provided in `value`. This may be | different from the operand data types if buffering is enabled. | finished : bool | Whether the iteration over the operands is finished or not. | has_delayed_bufalloc : bool | If True, the iterator was created with the "delay_bufalloc" flag, | and no reset() function was called on it yet. | has_index : bool | If True, the iterator was created with either the "c_index" or | the "f_index" flag, and the property `index` can be used to | retrieve it. | has_multi_index : bool | If True, the iterator was created with the "multi_index" flag, | and the property `multi_index` can be used to retrieve it. | index : | When the "c_index" or "f_index" flag was used, this property | provides access to the index. Raises a ValueError if accessed | and `has_index` is False. | iterationneedsapi : bool | Whether iteration requires access to the Python API, for example | if one of the operands is an object array. | iterindex : int | An index which matches the order of iteration. | itersize : int | Size of the iterator. | itviews : | Structured view(s) of `operands` in memory, matching the reordered | and optimized iterator access pattern. | multi_index : | When the "multi_index" flag was used, this property | provides access to the index. Raises a ValueError if accessed | accessed and `has_multi_index` is False. | ndim : int | The iterator's dimension. | nop : int | The number of iterator operands. | operands : tuple of operand(s) | The array(s) to be iterated over. | shape : tuple of ints | Shape tuple, the shape of the iterator. | value : | Value of `operands` at current iteration. Normally, this is a | tuple of array scalars, but if the flag "external_loop" is used, | it is a tuple of one dimensional arrays. | | Notes | ----- | `nditer` supersedes `flatiter`. The iterator implementation behind | `nditer` is also exposed by the Numpy C API. | | The Python exposure supplies two iteration interfaces, one which follows | the Python iterator protocol, and another which mirrors the C-style | do-while pattern. The native Python approach is better in most cases, but | if you need the iterator's coordinates or index, use the C-style pattern. | | Examples | -------- | Here is how we might write an ``iter_add`` function, using the | Python iterator protocol:: | | def iter_add_py(x, y, out=None): | addop = np.add | it = np.nditer([x, y, out], [], | [['readonly'], ['readonly'], ['writeonly','allocate']]) | for (a, b, c) in it: | addop(a, b, out=c) | return it.operands[2] | | Here is the same function, but following the C-style pattern:: | | def iter_add(x, y, out=None): | addop = np.add | | it = np.nditer([x, y, out], [], | [['readonly'], ['readonly'], ['writeonly','allocate']]) | | while not it.finished: | addop(it[0], it[1], out=it[2]) | it.iternext() | | return it.operands[2] | | Here is an example outer product function:: | | def outer_it(x, y, out=None): | mulop = np.multiply | | it = np.nditer([x, y, out], ['external_loop'], | [['readonly'], ['readonly'], ['writeonly', 'allocate']], | op_axes=[range(x.ndim)+[-1]*y.ndim, | [-1]*x.ndim+range(y.ndim), | None]) | | for (a, b, c) in it: | mulop(a, b, out=c) | | return it.operands[2] | | >>> a = np.arange(2)+1 | >>> b = np.arange(3)+1 | >>> outer_it(a,b) | array([[1, 2, 3], | [2, 4, 6]]) | | Here is an example function which operates like a "lambda" ufunc:: | | def luf(lamdaexpr, *args, **kwargs): | "luf(lambdaexpr, op1, ..., opn, out=None, order='K', casting='safe', buffersize=0)" | nargs = len(args) | op = (kwargs.get('out',None),) + args | it = np.nditer(op, ['buffered','external_loop'], | [['writeonly','allocate','no_broadcast']] + | [['readonly','nbo','aligned']]*nargs, | order=kwargs.get('order','K'), | casting=kwargs.get('casting','safe'), | buffersize=kwargs.get('buffersize',0)) | while not it.finished: | it[0] = lamdaexpr(*it[1:]) | it.iternext() | return it.operands[0] | | >>> a = np.arange(5) | >>> b = np.ones(5) | >>> luf(lambda i,j:i*i + j/2, a, b) | array([ 0.5, 1.5, 4.5, 9.5, 16.5]) | | Methods defined here: | | __copy__(...) | | __delitem__(...) | x.__delitem__(y) <==> del x[y] | | __delslice__(...) | x.__delslice__(i, j) <==> del x[i:j] | | Use of negative indices is not supported. | | __getitem__(...) | x.__getitem__(y) <==> x[y] | | __getslice__(...) | x.__getslice__(i, j) <==> x[i:j] | | Use of negative indices is not supported. | | __init__(...) | x.__init__(...) initializes x; see help(type(x)) for signature | | __iter__(...) | x.__iter__() <==> iter(x) | | __len__(...) | x.__len__() <==> len(x) | | __setitem__(...) | x.__setitem__(i, y) <==> x[i]=y | | __setslice__(...) | x.__setslice__(i, j, y) <==> x[i:j]=y | | Use of negative indices is not supported. | | copy(...) | copy() | | Get a copy of the iterator in its current state. | | Examples | -------- | >>> x = np.arange(10) | >>> y = x + 1 | >>> it = np.nditer([x, y]) | >>> it.next() | (array(0), array(1)) | >>> it2 = it.copy() | >>> it2.next() | (array(1), array(2)) | | debug_print(...) | debug_print() | | Print the current state of the `nditer` instance and debug info to stdout. | | enable_external_loop(...) | enable_external_loop() | | When the "external_loop" was not used during construction, but | is desired, this modifies the iterator to behave as if the flag | was specified. | | iternext(...) | iternext() | | Check whether iterations are left, and perform a single internal iteration | without returning the result. Used in the C-style pattern do-while | pattern. For an example, see `nditer`. | | Returns | ------- | iternext : bool | Whether or not there are iterations left. | | next(...) | x.next() -> the next value, or raise StopIteration | | remove_axis(...) | remove_axis(i) | | Removes axis `i` from the iterator. Requires that the flag "multi_index" | be enabled. | | remove_multi_index(...) | remove_multi_index() | | When the "multi_index" flag was specified, this removes it, allowing | the internal iteration structure to be optimized further. | | reset(...) | reset() | | Reset the iterator to its initial state. | | ---------------------------------------------------------------------- | Data descriptors defined here: | | dtypes | | finished | | has_delayed_bufalloc | | has_index | | has_multi_index | | index | | iterationneedsapi | | iterindex | | iterrange | | itersize | | itviews | | multi_index | | ndim | | nop | | operands | | shape | | value | | ---------------------------------------------------------------------- | Data and other attributes defined here: | | __new__ = <built-in method __new__ of type object> | T.__new__(S, ...) -> a new object with type S, a subtype of T class number(generic) | Method resolution order: | number | generic | __builtin__.object | | Methods inherited from generic: | | __abs__(...) | x.__abs__() <==> abs(x) | | __add__(...) | x.__add__(y) <==> x+y | | __and__(...) | x.__and__(y) <==> x&y | | __array__(...) | sc.__array__(|type) return 0-dim array | | __array_wrap__(...) | sc.__array_wrap__(obj) return scalar from array | | __copy__(...) | | __deepcopy__(...) | | __div__(...) | x.__div__(y) <==> x/y | | __divmod__(...) | x.__divmod__(y) <==> divmod(x, y) | | __eq__(...) | x.__eq__(y) <==> x==y | | __float__(...) | x.__float__() <==> float(x) | | __floordiv__(...) | x.__floordiv__(y) <==> x//y | | __format__(...) | NumPy array scalar formatter | | __ge__(...) | x.__ge__(y) <==> x>=y | | __getitem__(...) | x.__getitem__(y) <==> x[y] | | __gt__(...) | x.__gt__(y) <==> x>y | | __hex__(...) | x.__hex__() <==> hex(x) | | __int__(...) | x.__int__() <==> int(x) | | __invert__(...) | x.__invert__() <==> ~x | | __le__(...) | x.__le__(y) <==> x<=y | | __long__(...) | x.__long__() <==> long(x) | | __lshift__(...) | x.__lshift__(y) <==> x<<y | | __lt__(...) | x.__lt__(y) <==> x<y | | __mod__(...) | x.__mod__(y) <==> x%y | | __mul__(...) | x.__mul__(y) <==> x*y | | __ne__(...) | x.__ne__(y) <==> x!=y | | __neg__(...) | x.__neg__() <==> -x | | __nonzero__(...) | x.__nonzero__() <==> x != 0 | | __oct__(...) | x.__oct__() <==> oct(x) | | __or__(...) | x.__or__(y) <==> x|y | | __pos__(...) | x.__pos__() <==> +x | | __pow__(...) | x.__pow__(y[, z]) <==> pow(x, y[, z]) | | __radd__(...) | x.__radd__(y) <==> y+x | | __rand__(...) | x.__rand__(y) <==> y&x | | __rdiv__(...) | x.__rdiv__(y) <==> y/x | | __rdivmod__(...) | x.__rdivmod__(y) <==> divmod(y, x) | | __reduce__(...) | | __repr__(...) | x.__repr__() <==> repr(x) | | __rfloordiv__(...) | x.__rfloordiv__(y) <==> y//x | | __rlshift__(...) | x.__rlshift__(y) <==> y<<x | | __rmod__(...) | x.__rmod__(y) <==> y%x | | __rmul__(...) | x.__rmul__(y) <==> y*x | | __ror__(...) | x.__ror__(y) <==> y|x | | __rpow__(...) | y.__rpow__(x[, z]) <==> pow(x, y[, z]) | | __rrshift__(...) | x.__rrshift__(y) <==> y>>x | | __rshift__(...) | x.__rshift__(y) <==> x>>y | | __rsub__(...) | x.__rsub__(y) <==> y-x | | __rtruediv__(...) | x.__rtruediv__(y) <==> y/x | | __rxor__(...) | x.__rxor__(y) <==> y^x | | __setstate__(...) | | __sizeof__(...) | | __str__(...) | x.__str__() <==> str(x) | | __sub__(...) | x.__sub__(y) <==> x-y | | __truediv__(...) | x.__truediv__(y) <==> x/y | | __xor__(...) | x.__xor__(y) <==> x^y | | all(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | getfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | setfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | base | base object | | data | pointer to start of data | | dtype | get array data-descriptor | | flags | integer value of flags | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension object0 = class object_(generic) | Any Python object. Character code: 'O'. | | Method resolution order: | object_ | generic | __builtin__.object | | Methods defined here: | | __add__(...) | x.__add__(y) <==> x+y | | __call__(...) | x.__call__(...) <==> x(...) | | __contains__(...) | x.__contains__(y) <==> y in x | | __delattr__(...) | x.__delattr__('name') <==> del x.name | | __delitem__(...) | x.__delitem__(y) <==> del x[y] | | __eq__(...) | x.__eq__(y) <==> x==y | | __ge__(...) | x.__ge__(y) <==> x>=y | | __getattribute__(...) | x.__getattribute__('name') <==> x.name | | __getitem__(...) | x.__getitem__(y) <==> x[y] | | __gt__(...) | x.__gt__(y) <==> x>y | | __hash__(...) | x.__hash__() <==> hash(x) | | __iadd__(...) | x.__iadd__(y) <==> x+=y | | __imul__(...) | x.__imul__(y) <==> x*=y | | __le__(...) | x.__le__(y) <==> x<=y | | __len__(...) | x.__len__() <==> len(x) | | __lt__(...) | x.__lt__(y) <==> x<y | | __mul__(...) | x.__mul__(n) <==> x*n | | __ne__(...) | x.__ne__(y) <==> x!=y | | __rmul__(...) | x.__rmul__(n) <==> n*x | | __setattr__(...) | x.__setattr__('name', value) <==> x.name = value | | __setitem__(...) | x.__setitem__(i, y) <==> x[i]=y | | ---------------------------------------------------------------------- | Data and other attributes defined here: | | __new__ = <built-in method __new__ of type object> | T.__new__(S, ...) -> a new object with type S, a subtype of T | | ---------------------------------------------------------------------- | Methods inherited from generic: | | __abs__(...) | x.__abs__() <==> abs(x) | | __and__(...) | x.__and__(y) <==> x&y | | __array__(...) | sc.__array__(|type) return 0-dim array | | __array_wrap__(...) | sc.__array_wrap__(obj) return scalar from array | | __copy__(...) | | __deepcopy__(...) | | __div__(...) | x.__div__(y) <==> x/y | | __divmod__(...) | x.__divmod__(y) <==> divmod(x, y) | | __float__(...) | x.__float__() <==> float(x) | | __floordiv__(...) | x.__floordiv__(y) <==> x//y | | __format__(...) | NumPy array scalar formatter | | __hex__(...) | x.__hex__() <==> hex(x) | | __int__(...) | x.__int__() <==> int(x) | | __invert__(...) | x.__invert__() <==> ~x | | __long__(...) | x.__long__() <==> long(x) | | __lshift__(...) | x.__lshift__(y) <==> x<<y | | __mod__(...) | x.__mod__(y) <==> x%y | | __neg__(...) | x.__neg__() <==> -x | | __nonzero__(...) | x.__nonzero__() <==> x != 0 | | __oct__(...) | x.__oct__() <==> oct(x) | | __or__(...) | x.__or__(y) <==> x|y | | __pos__(...) | x.__pos__() <==> +x | | __pow__(...) | x.__pow__(y[, z]) <==> pow(x, y[, z]) | | __radd__(...) | x.__radd__(y) <==> y+x | | __rand__(...) | x.__rand__(y) <==> y&x | | __rdiv__(...) | x.__rdiv__(y) <==> y/x | | __rdivmod__(...) | x.__rdivmod__(y) <==> divmod(y, x) | | __reduce__(...) | | __repr__(...) | x.__repr__() <==> repr(x) | | __rfloordiv__(...) | x.__rfloordiv__(y) <==> y//x | | __rlshift__(...) | x.__rlshift__(y) <==> y<<x | | __rmod__(...) | x.__rmod__(y) <==> y%x | | __ror__(...) | x.__ror__(y) <==> y|x | | __rpow__(...) | y.__rpow__(x[, z]) <==> pow(x, y[, z]) | | __rrshift__(...) | x.__rrshift__(y) <==> y>>x | | __rshift__(...) | x.__rshift__(y) <==> x>>y | | __rsub__(...) | x.__rsub__(y) <==> y-x | | __rtruediv__(...) | x.__rtruediv__(y) <==> y/x | | __rxor__(...) | x.__rxor__(y) <==> y^x | | __setstate__(...) | | __sizeof__(...) | | __str__(...) | x.__str__() <==> str(x) | | __sub__(...) | x.__sub__(y) <==> x-y | | __truediv__(...) | x.__truediv__(y) <==> x/y | | __xor__(...) | x.__xor__(y) <==> x^y | | all(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | getfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | setfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | base | base object | | data | pointer to start of data | | dtype | get array data-descriptor | | flags | integer value of flags | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension class object_(generic) | Any Python object. Character code: 'O'. | | Method resolution order: | object_ | generic | __builtin__.object | | Methods defined here: | | __add__(...) | x.__add__(y) <==> x+y | | __call__(...) | x.__call__(...) <==> x(...) | | __contains__(...) | x.__contains__(y) <==> y in x | | __delattr__(...) | x.__delattr__('name') <==> del x.name | | __delitem__(...) | x.__delitem__(y) <==> del x[y] | | __eq__(...) | x.__eq__(y) <==> x==y | | __ge__(...) | x.__ge__(y) <==> x>=y | | __getattribute__(...) | x.__getattribute__('name') <==> x.name | | __getitem__(...) | x.__getitem__(y) <==> x[y] | | __gt__(...) | x.__gt__(y) <==> x>y | | __hash__(...) | x.__hash__() <==> hash(x) | | __iadd__(...) | x.__iadd__(y) <==> x+=y | | __imul__(...) | x.__imul__(y) <==> x*=y | | __le__(...) | x.__le__(y) <==> x<=y | | __len__(...) | x.__len__() <==> len(x) | | __lt__(...) | x.__lt__(y) <==> x<y | | __mul__(...) | x.__mul__(n) <==> x*n | | __ne__(...) | x.__ne__(y) <==> x!=y | | __rmul__(...) | x.__rmul__(n) <==> n*x | | __setattr__(...) | x.__setattr__('name', value) <==> x.name = value | | __setitem__(...) | x.__setitem__(i, y) <==> x[i]=y | | ---------------------------------------------------------------------- | Data and other attributes defined here: | | __new__ = <built-in method __new__ of type object> | T.__new__(S, ...) -> a new object with type S, a subtype of T | | ---------------------------------------------------------------------- | Methods inherited from generic: | | __abs__(...) | x.__abs__() <==> abs(x) | | __and__(...) | x.__and__(y) <==> x&y | | __array__(...) | sc.__array__(|type) return 0-dim array | | __array_wrap__(...) | sc.__array_wrap__(obj) return scalar from array | | __copy__(...) | | __deepcopy__(...) | | __div__(...) | x.__div__(y) <==> x/y | | __divmod__(...) | x.__divmod__(y) <==> divmod(x, y) | | __float__(...) | x.__float__() <==> float(x) | | __floordiv__(...) | x.__floordiv__(y) <==> x//y | | __format__(...) | NumPy array scalar formatter | | __hex__(...) | x.__hex__() <==> hex(x) | | __int__(...) | x.__int__() <==> int(x) | | __invert__(...) | x.__invert__() <==> ~x | | __long__(...) | x.__long__() <==> long(x) | | __lshift__(...) | x.__lshift__(y) <==> x<<y | | __mod__(...) | x.__mod__(y) <==> x%y | | __neg__(...) | x.__neg__() <==> -x | | __nonzero__(...) | x.__nonzero__() <==> x != 0 | | __oct__(...) | x.__oct__() <==> oct(x) | | __or__(...) | x.__or__(y) <==> x|y | | __pos__(...) | x.__pos__() <==> +x | | __pow__(...) | x.__pow__(y[, z]) <==> pow(x, y[, z]) | | __radd__(...) | x.__radd__(y) <==> y+x | | __rand__(...) | x.__rand__(y) <==> y&x | | __rdiv__(...) | x.__rdiv__(y) <==> y/x | | __rdivmod__(...) | x.__rdivmod__(y) <==> divmod(y, x) | | __reduce__(...) | | __repr__(...) | x.__repr__() <==> repr(x) | | __rfloordiv__(...) | x.__rfloordiv__(y) <==> y//x | | __rlshift__(...) | x.__rlshift__(y) <==> y<<x | | __rmod__(...) | x.__rmod__(y) <==> y%x | | __ror__(...) | x.__ror__(y) <==> y|x | | __rpow__(...) | y.__rpow__(x[, z]) <==> pow(x, y[, z]) | | __rrshift__(...) | x.__rrshift__(y) <==> y>>x | | __rshift__(...) | x.__rshift__(y) <==> x>>y | | __rsub__(...) | x.__rsub__(y) <==> y-x | | __rtruediv__(...) | x.__rtruediv__(y) <==> y/x | | __rxor__(...) | x.__rxor__(y) <==> y^x | | __setstate__(...) | | __sizeof__(...) | | __str__(...) | x.__str__() <==> str(x) | | __sub__(...) | x.__sub__(y) <==> x-y | | __truediv__(...) | x.__truediv__(y) <==> x/y | | __xor__(...) | x.__xor__(y) <==> x^y | | all(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | getfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | setfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | base | base object | | data | pointer to start of data | | dtype | get array data-descriptor | | flags | integer value of flags | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension class poly1d(__builtin__.object) | A one-dimensional polynomial class. | | A convenience class, used to encapsulate "natural" operations on | polynomials so that said operations may take on their customary | form in code (see Examples). | | Parameters | ---------- | c_or_r : array_like | The polynomial's coefficients, in decreasing powers, or if | the value of the second parameter is True, the polynomial's | roots (values where the polynomial evaluates to 0). For example, | ``poly1d([1, 2, 3])`` returns an object that represents | :math:`x^2 + 2x + 3`, whereas ``poly1d([1, 2, 3], True)`` returns | one that represents :math:`(x-1)(x-2)(x-3) = x^3 - 6x^2 + 11x -6`. | r : bool, optional | If True, `c_or_r` specifies the polynomial's roots; the default | is False. | variable : str, optional | Changes the variable used when printing `p` from `x` to `variable` | (see Examples). | | Examples | -------- | Construct the polynomial :math:`x^2 + 2x + 3`: | | >>> p = np.poly1d([1, 2, 3]) | >>> print np.poly1d(p) | 2 | 1 x + 2 x + 3 | | Evaluate the polynomial at :math:`x = 0.5`: | | >>> p(0.5) | 4.25 | | Find the roots: | | >>> p.r | array([-1.+1.41421356j, -1.-1.41421356j]) | >>> p(p.r) | array([ -4.44089210e-16+0.j, -4.44089210e-16+0.j]) | | These numbers in the previous line represent (0, 0) to machine precision | | Show the coefficients: | | >>> p.c | array([1, 2, 3]) | | Display the order (the leading zero-coefficients are removed): | | >>> p.order | 2 | | Show the coefficient of the k-th power in the polynomial | (which is equivalent to ``p.c[-(i+1)]``): | | >>> p[1] | 2 | | Polynomials can be added, subtracted, multiplied, and divided | (returns quotient and remainder): | | >>> p * p | poly1d([ 1, 4, 10, 12, 9]) | | >>> (p**3 + 4) / p | (poly1d([ 1., 4., 10., 12., 9.]), poly1d([ 4.])) | | ``asarray(p)`` gives the coefficient array, so polynomials can be | used in all functions that accept arrays: | | >>> p**2 # square of polynomial | poly1d([ 1, 4, 10, 12, 9]) | | >>> np.square(p) # square of individual coefficients | array([1, 4, 9]) | | The variable used in the string representation of `p` can be modified, | using the `variable` parameter: | | >>> p = np.poly1d([1,2,3], variable='z') | >>> print p | 2 | 1 z + 2 z + 3 | | Construct a polynomial from its roots: | | >>> np.poly1d([1, 2], True) | poly1d([ 1, -3, 2]) | | This is the same polynomial as obtained by: | | >>> np.poly1d([1, -1]) * np.poly1d([1, -2]) | poly1d([ 1, -3, 2]) | | Methods defined here: | | __add__(self, other) | | __array__(self, t=None) | | __call__(self, val) | | __div__(self, other) | | __eq__(self, other) | | __getattr__(self, key) | | __getitem__(self, val) | | __init__(self, c_or_r, r=0, variable=None) | | __iter__(self) | | __len__(self) | | __mul__(self, other) | | __ne__(self, other) | | __neg__(self) | | __pos__(self) | | __pow__(self, val) | | __radd__(self, other) | | __rdiv__(self, other) | | __repr__(self) | | __rmul__(self, other) | | __rsub__(self, other) | | __rtruediv__ = __rdiv__(self, other) | | __setattr__(self, key, val) | | __setitem__(self, key, val) | | __str__(self) | | __sub__(self, other) | | __truediv__ = __div__(self, other) | | deriv(self, m=1) | Return a derivative of this polynomial. | | Refer to `polyder` for full documentation. | | See Also | -------- | polyder : equivalent function | | integ(self, m=1, k=0) | Return an antiderivative (indefinite integral) of this polynomial. | | Refer to `polyint` for full documentation. | | See Also | -------- | polyint : equivalent function | | ---------------------------------------------------------------------- | Data descriptors defined here: | | __dict__ | dictionary for instance variables (if defined) | | __weakref__ | list of weak references to the object (if defined) | | ---------------------------------------------------------------------- | Data and other attributes defined here: | | __hash__ = None | | coeffs = None | | order = None | | variable = None class recarray(ndarray) | Construct an ndarray that allows field access using attributes. | | Arrays may have a data-types containing fields, analogous | to columns in a spread sheet. An example is ``[(x, int), (y, float)]``, | where each entry in the array is a pair of ``(int, float)``. Normally, | these attributes are accessed using dictionary lookups such as ``arr['x']`` | and ``arr['y']``. Record arrays allow the fields to be accessed as members | of the array, using ``arr.x`` and ``arr.y``. | | Parameters | ---------- | shape : tuple | Shape of output array. | dtype : data-type, optional | The desired data-type. By default, the data-type is determined | from `formats`, `names`, `titles`, `aligned` and `byteorder`. | formats : list of data-types, optional | A list containing the data-types for the different columns, e.g. | ``['i4', 'f8', 'i4']``. `formats` does *not* support the new | convention of using types directly, i.e. ``(int, float, int)``. | Note that `formats` must be a list, not a tuple. | Given that `formats` is somewhat limited, we recommend specifying | `dtype` instead. | names : tuple of str, optional | The name of each column, e.g. ``('x', 'y', 'z')``. | buf : buffer, optional | By default, a new array is created of the given shape and data-type. | If `buf` is specified and is an object exposing the buffer interface, | the array will use the memory from the existing buffer. In this case, | the `offset` and `strides` keywords are available. | | Other Parameters | ---------------- | titles : tuple of str, optional | Aliases for column names. For example, if `names` were | ``('x', 'y', 'z')`` and `titles` is | ``('x_coordinate', 'y_coordinate', 'z_coordinate')``, then | ``arr['x']`` is equivalent to both ``arr.x`` and ``arr.x_coordinate``. | byteorder : {'<', '>', '='}, optional | Byte-order for all fields. | aligned : bool, optional | Align the fields in memory as the C-compiler would. | strides : tuple of ints, optional | Buffer (`buf`) is interpreted according to these strides (strides | define how many bytes each array element, row, column, etc. | occupy in memory). | offset : int, optional | Start reading buffer (`buf`) from this offset onwards. | order : {'C', 'F'}, optional | Row-major (C-style) or column-major (Fortran-style) order. | | Returns | ------- | rec : recarray | Empty array of the given shape and type. | | See Also | -------- | rec.fromrecords : Construct a record array from data. | record : fundamental data-type for `recarray`. | format_parser : determine a data-type from formats, names, titles. | | Notes | ----- | This constructor can be compared to ``empty``: it creates a new record | array but does not fill it with data. To create a record array from data, | use one of the following methods: | | 1. Create a standard ndarray and convert it to a record array, | using ``arr.view(np.recarray)`` | 2. Use the `buf` keyword. | 3. Use `np.rec.fromrecords`. | | Examples | -------- | Create an array with two fields, ``x`` and ``y``: | | >>> x = np.array([(1.0, 2), (3.0, 4)], dtype=[('x', float), ('y', int)]) | >>> x | array([(1.0, 2), (3.0, 4)], | dtype=[('x', '<f8'), ('y', '<i4')]) | | >>> x['x'] | array([ 1., 3.]) | | View the array as a record array: | | >>> x = x.view(np.recarray) | | >>> x.x | array([ 1., 3.]) | | >>> x.y | array([2, 4]) | | Create a new, empty record array: | | >>> np.recarray((2,), | ... dtype=[('x', int), ('y', float), ('z', int)]) #doctest: +SKIP | rec.array([(-1073741821, 1.2249118382103472e-301, 24547520), | (3471280, 1.2134086255804012e-316, 0)], | dtype=[('x', '<i4'), ('y', '<f8'), ('z', '<i4')]) | | Method resolution order: | recarray | ndarray | __builtin__.object | | Methods defined here: | | __array_finalize__(self, obj) | | __getattribute__(self, attr) | | __getitem__(self, indx) | | __repr__(self) | | __setattr__(self, attr, val) | # Save the dictionary. | # If the attr is a field name and not in the saved dictionary | # Undo any "setting" of the attribute and do a setfield | # Thus, you can't create attributes on-the-fly that are field names. | | field(self, attr, val=None) | | ---------------------------------------------------------------------- | Static methods defined here: | | __new__(subtype, shape, dtype=None, buf=None, offset=0, strides=None, formats=None, names=None, titles=None, byteorder=None, aligned=False, order='C') | | ---------------------------------------------------------------------- | Data descriptors defined here: | | __dict__ | dictionary for instance variables (if defined) | | ---------------------------------------------------------------------- | Methods inherited from ndarray: | | __abs__(...) | x.__abs__() <==> abs(x) | | __add__(...) | x.__add__(y) <==> x+y | | __and__(...) | x.__and__(y) <==> x&y | | __array__(...) | a.__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. | | __array_prepare__(...) | a.__array_prepare__(obj) -> Object of same type as ndarray object obj. | | __array_wrap__(...) | a.__array_wrap__(obj) -> Object of same type as ndarray object a. | | __contains__(...) | x.__contains__(y) <==> y in x | | __copy__(...) | a.__copy__([order]) | | Return a copy of the array. | | Parameters | ---------- | order : {'C', 'F', 'A'}, optional | If order is 'C' (False) then the result is contiguous (default). | If order is 'Fortran' (True) then the result has fortran order. | If order is 'Any' (None) then the result has fortran order | only if the array already is in fortran order. | | __deepcopy__(...) | a.__deepcopy__() -> Deep copy of array. | | Used if copy.deepcopy is called on an array. | | __delitem__(...) | x.__delitem__(y) <==> del x[y] | | __delslice__(...) | x.__delslice__(i, j) <==> del x[i:j] | | Use of negative indices is not supported. | | __div__(...) | x.__div__(y) <==> x/y | | __divmod__(...) | x.__divmod__(y) <==> divmod(x, y) | | __eq__(...) | x.__eq__(y) <==> x==y | | __float__(...) | x.__float__() <==> float(x) | | __floordiv__(...) | x.__floordiv__(y) <==> x//y | | __ge__(...) | x.__ge__(y) <==> x>=y | | __getslice__(...) | x.__getslice__(i, j) <==> x[i:j] | | Use of negative indices is not supported. | | __gt__(...) | x.__gt__(y) <==> x>y | | __hex__(...) | x.__hex__() <==> hex(x) | | __iadd__(...) | x.__iadd__(y) <==> x+=y | | __iand__(...) | x.__iand__(y) <==> x&=y | | __idiv__(...) | x.__idiv__(y) <==> x/=y | | __ifloordiv__(...) | x.__ifloordiv__(y) <==> x//=y | | __ilshift__(...) | x.__ilshift__(y) <==> x<<=y | | __imod__(...) | x.__imod__(y) <==> x%=y | | __imul__(...) | x.__imul__(y) <==> x*=y | | __index__(...) | x[y:z] <==> x[y.__index__():z.__index__()] | | __int__(...) | x.__int__() <==> int(x) | | __invert__(...) | x.__invert__() <==> ~x | | __ior__(...) | x.__ior__(y) <==> x|=y | | __ipow__(...) | x.__ipow__(y) <==> x**=y | | __irshift__(...) | x.__irshift__(y) <==> x>>=y | | __isub__(...) | x.__isub__(y) <==> x-=y | | __iter__(...) | x.__iter__() <==> iter(x) | | __itruediv__(...) | x.__itruediv__(y) <==> x/=y | | __ixor__(...) | x.__ixor__(y) <==> x^=y | | __le__(...) | x.__le__(y) <==> x<=y | | __len__(...) | x.__len__() <==> len(x) | | __long__(...) | x.__long__() <==> long(x) | | __lshift__(...) | x.__lshift__(y) <==> x<<y | | __lt__(...) | x.__lt__(y) <==> x<y | | __mod__(...) | x.__mod__(y) <==> x%y | | __mul__(...) | x.__mul__(y) <==> x*y | | __ne__(...) | x.__ne__(y) <==> x!=y | | __neg__(...) | x.__neg__() <==> -x | | __nonzero__(...) | x.__nonzero__() <==> x != 0 | | __oct__(...) | x.__oct__() <==> oct(x) | | __or__(...) | x.__or__(y) <==> x|y | | __pos__(...) | x.__pos__() <==> +x | | __pow__(...) | x.__pow__(y[, z]) <==> pow(x, y[, z]) | | __radd__(...) | x.__radd__(y) <==> y+x | | __rand__(...) | x.__rand__(y) <==> y&x | | __rdiv__(...) | x.__rdiv__(y) <==> y/x | | __rdivmod__(...) | x.__rdivmod__(y) <==> divmod(y, x) | | __reduce__(...) | a.__reduce__() | | For pickling. | | __rfloordiv__(...) | x.__rfloordiv__(y) <==> y//x | | __rlshift__(...) | x.__rlshift__(y) <==> y<<x | | __rmod__(...) | x.__rmod__(y) <==> y%x | | __rmul__(...) | x.__rmul__(y) <==> y*x | | __ror__(...) | x.__ror__(y) <==> y|x | | __rpow__(...) | y.__rpow__(x[, z]) <==> pow(x, y[, z]) | | __rrshift__(...) | x.__rrshift__(y) <==> y>>x | | __rshift__(...) | x.__rshift__(y) <==> x>>y | | __rsub__(...) | x.__rsub__(y) <==> y-x | | __rtruediv__(...) | x.__rtruediv__(y) <==> y/x | | __rxor__(...) | x.__rxor__(y) <==> y^x | | __setitem__(...) | x.__setitem__(i, y) <==> x[i]=y | | __setslice__(...) | x.__setslice__(i, j, y) <==> x[i:j]=y | | Use of negative indices is not supported. | | __setstate__(...) | a.__setstate__(version, shape, dtype, isfortran, rawdata) | | For unpickling. | | Parameters | ---------- | version : int | optional pickle version. If omitted defaults to 0. | shape : tuple | dtype : data-type | isFortran : bool | rawdata : string or list | a binary string with the data (or a list if 'a' is an object array) | | __sizeof__(...) | | __str__(...) | x.__str__() <==> str(x) | | __sub__(...) | x.__sub__(y) <==> x-y | | __truediv__(...) | x.__truediv__(y) <==> x/y | | __xor__(...) | x.__xor__(y) <==> x^y | | all(...) | a.all(axis=None, out=None, keepdims=False) | | Returns True if all elements evaluate to True. | | Refer to `numpy.all` for full documentation. | | See Also | -------- | numpy.all : equivalent function | | any(...) | a.any(axis=None, out=None, keepdims=False) | | Returns True if any of the elements of `a` evaluate to True. | | Refer to `numpy.any` for full documentation. | | See Also | -------- | numpy.any : equivalent function | | argmax(...) | a.argmax(axis=None, out=None) | | Return indices of the maximum values along the given axis. | | Refer to `numpy.argmax` for full documentation. | | See Also | -------- | numpy.argmax : equivalent function | | argmin(...) | a.argmin(axis=None, out=None) | | Return indices of the minimum values along the given axis of `a`. | | Refer to `numpy.argmin` for detailed documentation. | | See Also | -------- | numpy.argmin : equivalent function | | argpartition(...) | a.argpartition(kth, axis=-1, kind='introselect', order=None) | | Returns the indices that would partition this array. | | Refer to `numpy.argpartition` for full documentation. | | .. versionadded:: 1.8.0 | | See Also | -------- | numpy.argpartition : equivalent function | | argsort(...) | a.argsort(axis=-1, kind='quicksort', order=None) | | Returns the indices that would sort this array. | | Refer to `numpy.argsort` for full documentation. | | See Also | -------- | numpy.argsort : equivalent function | | astype(...) | a.astype(dtype, order='K', casting='unsafe', subok=True, copy=True) | | Copy of the array, cast to a specified type. | | Parameters | ---------- | dtype : str or dtype | Typecode or data-type to which the array is cast. | order : {'C', 'F', 'A', 'K'}, optional | Controls the memory layout order of the result. | 'C' means C order, 'F' means Fortran order, 'A' | means 'F' order if all the arrays are Fortran contiguous, | 'C' order otherwise, and 'K' means as close to the | order the array elements appear in memory as possible. | Default is 'K'. | casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional | Controls what kind of data casting may occur. Defaults to 'unsafe' | for backwards compatibility. | | * 'no' means the data types should not be cast at all. | * 'equiv' means only byte-order changes are allowed. | * 'safe' means only casts which can preserve values are allowed. | * 'same_kind' means only safe casts or casts within a kind, | like float64 to float32, are allowed. | * 'unsafe' means any data conversions may be done. | subok : bool, optional | If True, then sub-classes will be passed-through (default), otherwise | the returned array will be forced to be a base-class array. | copy : bool, optional | By default, astype always returns a newly allocated array. If this | is set to false, and the `dtype`, `order`, and `subok` | requirements are satisfied, the input array is returned instead | of a copy. | | Returns | ------- | arr_t : ndarray | Unless `copy` is False and the other conditions for returning the input | array are satisfied (see description for `copy` input paramter), `arr_t` | is a new array of the same shape as the input array, with dtype, order | given by `dtype`, `order`. | | Notes | ----- | Starting in NumPy 1.9, astype method now returns an error if the string | dtype to cast to is not long enough in 'safe' casting mode to hold the max | value of integer/float array that is being casted. Previously the casting | was allowed even if the result was truncated. | | Raises | ------ | ComplexWarning | When casting from complex to float or int. To avoid this, | one should use ``a.real.astype(t)``. | | Examples | -------- | >>> x = np.array([1, 2, 2.5]) | >>> x | array([ 1. , 2. , 2.5]) | | >>> x.astype(int) | array([1, 2, 2]) | | byteswap(...) | a.byteswap(inplace) | | Swap the bytes of the array elements | | Toggle between low-endian and big-endian data representation by | returning a byteswapped array, optionally swapped in-place. | | Parameters | ---------- | inplace : bool, optional | If ``True``, swap bytes in-place, default is ``False``. | | Returns | ------- | out : ndarray | The byteswapped array. If `inplace` is ``True``, this is | a view to self. | | Examples | -------- | >>> A = np.array([1, 256, 8755], dtype=np.int16) | >>> map(hex, A) | ['0x1', '0x100', '0x2233'] | >>> A.byteswap(True) | array([ 256, 1, 13090], dtype=int16) | >>> map(hex, A) | ['0x100', '0x1', '0x3322'] | | Arrays of strings are not swapped | | >>> A = np.array(['ceg', 'fac']) | >>> A.byteswap() | array(['ceg', 'fac'], | dtype='|S3') | | choose(...) | a.choose(choices, out=None, mode='raise') | | Use an index array to construct a new array from a set of choices. | | Refer to `numpy.choose` for full documentation. | | See Also | -------- | numpy.choose : equivalent function | | clip(...) | a.clip(min=None, max=None, out=None) | | Return an array whose values are limited to ``[min, max]``. | One of max or min must be given. | | Refer to `numpy.clip` for full documentation. | | See Also | -------- | numpy.clip : equivalent function | | compress(...) | a.compress(condition, axis=None, out=None) | | Return selected slices of this array along given axis. | | Refer to `numpy.compress` for full documentation. | | See Also | -------- | numpy.compress : equivalent function | | conj(...) | a.conj() | | Complex-conjugate all elements. | | Refer to `numpy.conjugate` for full documentation. | | See Also | -------- | numpy.conjugate : equivalent function | | conjugate(...) | a.conjugate() | | Return the complex conjugate, element-wise. | | Refer to `numpy.conjugate` for full documentation. | | See Also | -------- | numpy.conjugate : equivalent function | | copy(...) | 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.) | | See also | -------- | numpy.copy | numpy.copyto | | Examples | -------- | >>> x = np.array([[1,2,3],[4,5,6]], order='F') | | >>> y = x.copy() | | >>> x.fill(0) | | >>> x | array([[0, 0, 0], | [0, 0, 0]]) | | >>> y | array([[1, 2, 3], | [4, 5, 6]]) | | >>> y.flags['C_CONTIGUOUS'] | True | | cumprod(...) | a.cumprod(axis=None, dtype=None, out=None) | | Return the cumulative product of the elements along the given axis. | | Refer to `numpy.cumprod` for full documentation. | | See Also | -------- | numpy.cumprod : equivalent function | | cumsum(...) | a.cumsum(axis=None, dtype=None, out=None) | | Return the cumulative sum of the elements along the given axis. | | Refer to `numpy.cumsum` for full documentation. | | See Also | -------- | numpy.cumsum : equivalent function | | diagonal(...) | a.diagonal(offset=0, axis1=0, axis2=1) | | Return specified diagonals. In NumPy 1.9 the returned array is a | read-only view instead of a copy as in previous NumPy versions. In | NumPy 1.10 the read-only restriction will be removed. | | Refer to :func:`numpy.diagonal` for full documentation. | | See Also | -------- | numpy.diagonal : equivalent function | | dot(...) | a.dot(b, out=None) | | Dot product of two arrays. | | Refer to `numpy.dot` for full documentation. | | See Also | -------- | numpy.dot : equivalent function | | Examples | -------- | >>> a = np.eye(2) | >>> b = np.ones((2, 2)) * 2 | >>> a.dot(b) | array([[ 2., 2.], | [ 2., 2.]]) | | This array method can be conveniently chained: | | >>> a.dot(b).dot(b) | array([[ 8., 8.], | [ 8., 8.]]) | | dump(...) | a.dump(file) | | Dump a pickle of the array to the specified file. | The array can be read back with pickle.load or numpy.load. | | Parameters | ---------- | file : str | A string naming the dump file. | | dumps(...) | a.dumps() | | Returns the pickle of the array as a string. | pickle.loads or numpy.loads will convert the string back to an array. | | Parameters | ---------- | None | | fill(...) | a.fill(value) | | Fill the array with a scalar value. | | Parameters | ---------- | value : scalar | All elements of `a` will be assigned this value. | | Examples | -------- | >>> a = np.array([1, 2]) | >>> a.fill(0) | >>> a | array([0, 0]) | >>> a = np.empty(2) | >>> a.fill(1) | >>> a | array([ 1., 1.]) | | flatten(...) | a.flatten(order='C') | | Return a copy of the array collapsed into one dimension. | | Parameters | ---------- | order : {'C', 'F', 'A'}, optional | Whether to flatten in row-major (C-style) or | column-major (Fortran-style) order or preserve the | C/Fortran ordering from `a`. The default is 'C'. | | Returns | ------- | y : ndarray | A copy of the input array, flattened to one dimension. | | See Also | -------- | ravel : Return a flattened array. | flat : A 1-D flat iterator over the array. | | Examples | -------- | >>> a = np.array([[1,2], [3,4]]) | >>> a.flatten() | array([1, 2, 3, 4]) | >>> a.flatten('F') | array([1, 3, 2, 4]) | | getfield(...) | a.getfield(dtype, offset=0) | | Returns a field of the given array as a certain type. | | A field is a view of the array data with a given data-type. The values in | the view are determined by the given type and the offset into the current | array in bytes. The offset needs to be such that the view dtype fits in the | array dtype; for example an array of dtype complex128 has 16-byte elements. | If taking a view with a 32-bit integer (4 bytes), the offset needs to be | between 0 and 12 bytes. | | Parameters | ---------- | dtype : str or dtype | The data type of the view. The dtype size of the view can not be larger | than that of the array itself. | offset : int | Number of bytes to skip before beginning the element view. | | Examples | -------- | >>> x = np.diag([1.+1.j]*2) | >>> x[1, 1] = 2 + 4.j | >>> x | array([[ 1.+1.j, 0.+0.j], | [ 0.+0.j, 2.+4.j]]) | >>> x.getfield(np.float64) | array([[ 1., 0.], | [ 0., 2.]]) | | By choosing an offset of 8 bytes we can select the complex part of the | array for our view: | | >>> x.getfield(np.float64, offset=8) | array([[ 1., 0.], | [ 0., 4.]]) | | item(...) | a.item(*args) | | Copy an element of an array to a standard Python scalar and return it. | | Parameters | ---------- | \*args : Arguments (variable number and type) | | * none: in this case, the method only works for arrays | with one element (`a.size == 1`), which element is | copied into a standard Python scalar object and returned. | | * int_type: this argument is interpreted as a flat index into | the array, specifying which element to copy and return. | | * tuple of int_types: functions as does a single int_type argument, | except that the argument is interpreted as an nd-index into the | array. | | Returns | ------- | z : Standard Python scalar object | A copy of the specified element of the array as a suitable | Python scalar | | Notes | ----- | When the data type of `a` is longdouble or clongdouble, item() returns | a scalar array object because there is no available Python scalar that | would not lose information. Void arrays return a buffer object for item(), | unless fields are defined, in which case a tuple is returned. | | `item` is very similar to a[args], except, instead of an array scalar, | a standard Python scalar is returned. This can be useful for speeding up | access to elements of the array and doing arithmetic on elements of the | array using Python's optimized math. | | Examples | -------- | >>> x = np.random.randint(9, size=(3, 3)) | >>> x | array([[3, 1, 7], | [2, 8, 3], | [8, 5, 3]]) | >>> x.item(3) | 2 | >>> x.item(7) | 5 | >>> x.item((0, 1)) | 1 | >>> x.item((2, 2)) | 3 | | itemset(...) | a.itemset(*args) | | Insert scalar into an array (scalar is cast to array's dtype, if possible) | | There must be at least 1 argument, and define the last argument | as *item*. Then, ``a.itemset(*args)`` is equivalent to but faster | than ``a[args] = item``. The item should be a scalar value and `args` | must select a single item in the array `a`. | | Parameters | ---------- | \*args : Arguments | If one argument: a scalar, only used in case `a` is of size 1. | If two arguments: the last argument is the value to be set | and must be a scalar, the first argument specifies a single array | element location. It is either an int or a tuple. | | Notes | ----- | Compared to indexing syntax, `itemset` provides some speed increase | for placing a scalar into a particular location in an `ndarray`, | if you must do this. However, generally this is discouraged: | among other problems, it complicates the appearance of the code. | Also, when using `itemset` (and `item`) inside a loop, be sure | to assign the methods to a local variable to avoid the attribute | look-up at each loop iteration. | | Examples | -------- | >>> x = np.random.randint(9, size=(3, 3)) | >>> x | array([[3, 1, 7], | [2, 8, 3], | [8, 5, 3]]) | >>> x.itemset(4, 0) | >>> x.itemset((2, 2), 9) | >>> x | array([[3, 1, 7], | [2, 0, 3], | [8, 5, 9]]) | | max(...) | a.max(axis=None, out=None) | | Return the maximum along a given axis. | | Refer to `numpy.amax` for full documentation. | | See Also | -------- | numpy.amax : equivalent function | | mean(...) | a.mean(axis=None, dtype=None, out=None, keepdims=False) | | Returns the average of the array elements along given axis. | | Refer to `numpy.mean` for full documentation. | | See Also | -------- | numpy.mean : equivalent function | | min(...) | a.min(axis=None, out=None, keepdims=False) | | Return the minimum along a given axis. | | Refer to `numpy.amin` for full documentation. | | See Also | -------- | numpy.amin : equivalent function | | newbyteorder(...) | arr.newbyteorder(new_order='S') | | Return the array with the same data viewed with a different byte order. | | Equivalent to:: | | arr.view(arr.dtype.newbytorder(new_order)) | | Changes are also made in all fields and sub-arrays of the array data | type. | | | | Parameters | ---------- | new_order : string, optional | Byte order to force; a value from the byte order specifications | below. `new_order` codes can be any of: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_arr : array | New array object with the dtype reflecting given change to the | byte order. | | nonzero(...) | a.nonzero() | | Return the indices of the elements that are non-zero. | | Refer to `numpy.nonzero` for full documentation. | | See Also | -------- | numpy.nonzero : equivalent function | | partition(...) | a.partition(kth, axis=-1, kind='introselect', order=None) | | Rearranges the elements in the array in such a way that value of the | element in kth position is in the position it would be in a sorted array. | All elements smaller than the kth element are moved before this element and | all equal or greater are moved behind it. The ordering of the elements in | the two partitions is undefined. | | .. versionadded:: 1.8.0 | | Parameters | ---------- | kth : int or sequence of ints | Element index to partition by. The kth element value will be in its | final sorted position and all smaller elements will be moved before it | and all equal or greater elements behind it. | The order all elements in the partitions is undefined. | If provided with a sequence of kth it will partition all elements | indexed by kth of them into their sorted position at once. | axis : int, optional | Axis along which to sort. Default is -1, which means sort along the | last axis. | kind : {'introselect'}, optional | Selection algorithm. Default is 'introselect'. | order : str or list of str, optional | When `a` is an array with fields defined, this argument specifies | which fields to compare first, second, etc. A single field can | be specified as a string, and not all fields need be specified, | but unspecified fields will still be used, in the order in which | they come up in the dtype, to break ties. | | See Also | -------- | numpy.partition : Return a parititioned copy of an array. | argpartition : Indirect partition. | sort : Full sort. | | Notes | ----- | See ``np.partition`` for notes on the different algorithms. | | Examples | -------- | >>> a = np.array([3, 4, 2, 1]) | >>> a.partition(a, 3) | >>> a | array([2, 1, 3, 4]) | | >>> a.partition((1, 3)) | array([1, 2, 3, 4]) | | prod(...) | a.prod(axis=None, dtype=None, out=None, keepdims=False) | | Return the product of the array elements over the given axis | | Refer to `numpy.prod` for full documentation. | | See Also | -------- | numpy.prod : equivalent function | | ptp(...) | a.ptp(axis=None, out=None) | | Peak to peak (maximum - minimum) value along a given axis. | | Refer to `numpy.ptp` for full documentation. | | See Also | -------- | numpy.ptp : equivalent function | | put(...) | a.put(indices, values, mode='raise') | | Set ``a.flat[n] = values[n]`` for all `n` in indices. | | Refer to `numpy.put` for full documentation. | | See Also | -------- | numpy.put : equivalent function | | ravel(...) | a.ravel([order]) | | Return a flattened array. | | Refer to `numpy.ravel` for full documentation. | | See Also | -------- | numpy.ravel : equivalent function | | ndarray.flat : a flat iterator on the array. | | repeat(...) | a.repeat(repeats, axis=None) | | Repeat elements of an array. | | Refer to `numpy.repeat` for full documentation. | | See Also | -------- | numpy.repeat : equivalent function | | reshape(...) | a.reshape(shape, order='C') | | Returns an array containing the same data with a new shape. | | Refer to `numpy.reshape` for full documentation. | | See Also | -------- | numpy.reshape : equivalent function | | resize(...) | a.resize(new_shape, refcheck=True) | | Change shape and size of array in-place. | | Parameters | ---------- | new_shape : tuple of ints, or `n` ints | Shape of resized array. | refcheck : bool, optional | If False, reference count will not be checked. Default is True. | | Returns | ------- | None | | Raises | ------ | ValueError | If `a` does not own its own data or references or views to it exist, | and the data memory must be changed. | | SystemError | If the `order` keyword argument is specified. This behaviour is a | bug in NumPy. | | See Also | -------- | resize : Return a new array with the specified shape. | | Notes | ----- | This reallocates space for the data area if necessary. | | Only contiguous arrays (data elements consecutive in memory) can be | resized. | | The purpose of the reference count check is to make sure you | do not use this array as a buffer for another Python object and then | reallocate the memory. However, reference counts can increase in | other ways so if you are sure that you have not shared the memory | for this array with another Python object, then you may safely set | `refcheck` to False. | | Examples | -------- | Shrinking an array: array is flattened (in the order that the data are | stored in memory), resized, and reshaped: | | >>> a = np.array([[0, 1], [2, 3]], order='C') | >>> a.resize((2, 1)) | >>> a | array([[0], | [1]]) | | >>> a = np.array([[0, 1], [2, 3]], order='F') | >>> a.resize((2, 1)) | >>> a | array([[0], | [2]]) | | Enlarging an array: as above, but missing entries are filled with zeros: | | >>> b = np.array([[0, 1], [2, 3]]) | >>> b.resize(2, 3) # new_shape parameter doesn't have to be a tuple | >>> b | array([[0, 1, 2], | [3, 0, 0]]) | | Referencing an array prevents resizing... | | >>> c = a | >>> a.resize((1, 1)) | Traceback (most recent call last): | ... | ValueError: cannot resize an array that has been referenced ... | | Unless `refcheck` is False: | | >>> a.resize((1, 1), refcheck=False) | >>> a | array([[0]]) | >>> c | array([[0]]) | | round(...) | a.round(decimals=0, out=None) | | Return `a` with each element rounded to the given number of decimals. | | Refer to `numpy.around` for full documentation. | | See Also | -------- | numpy.around : equivalent function | | searchsorted(...) | a.searchsorted(v, side='left', sorter=None) | | Find indices where elements of v should be inserted in a to maintain order. | | For full documentation, see `numpy.searchsorted` | | See Also | -------- | numpy.searchsorted : equivalent function | | setfield(...) | a.setfield(val, dtype, offset=0) | | Put a value into a specified place in a field defined by a data-type. | | Place `val` into `a`'s field defined by `dtype` and beginning `offset` | bytes into the field. | | Parameters | ---------- | val : object | Value to be placed in field. | dtype : dtype object | Data-type of the field in which to place `val`. | offset : int, optional | The number of bytes into the field at which to place `val`. | | Returns | ------- | None | | See Also | -------- | getfield | | Examples | -------- | >>> x = np.eye(3) | >>> x.getfield(np.float64) | array([[ 1., 0., 0.], | [ 0., 1., 0.], | [ 0., 0., 1.]]) | >>> x.setfield(3, np.int32) | >>> x.getfield(np.int32) | array([[3, 3, 3], | [3, 3, 3], | [3, 3, 3]]) | >>> x | array([[ 1.00000000e+000, 1.48219694e-323, 1.48219694e-323], | [ 1.48219694e-323, 1.00000000e+000, 1.48219694e-323], | [ 1.48219694e-323, 1.48219694e-323, 1.00000000e+000]]) | >>> x.setfield(np.eye(3), np.int32) | >>> x | array([[ 1., 0., 0.], | [ 0., 1., 0.], | [ 0., 0., 1.]]) | | setflags(...) | a.setflags(write=None, align=None, uic=None) | | Set array flags WRITEABLE, ALIGNED, and UPDATEIFCOPY, respectively. | | These Boolean-valued flags affect how numpy interprets the memory | area used by `a` (see Notes below). The ALIGNED flag can only | be set to True if the data is actually aligned according to the type. | The UPDATEIFCOPY flag can never be set to True. The flag WRITEABLE | can only be set to True if the array owns its own memory, or the | ultimate owner of the memory exposes a writeable buffer interface, | or is a string. (The exception for string is made so that unpickling | can be done without copying memory.) | | Parameters | ---------- | write : bool, optional | Describes whether or not `a` can be written to. | align : bool, optional | Describes whether or not `a` is aligned properly for its type. | uic : bool, optional | Describes whether or not `a` is a copy of another "base" array. | | Notes | ----- | Array flags provide information about how the memory area used | for the array is to be interpreted. There are 6 Boolean flags | in use, only three of which can be changed by the user: | UPDATEIFCOPY, WRITEABLE, and ALIGNED. | | WRITEABLE (W) the data area can be written to; | | ALIGNED (A) the data and strides are aligned appropriately for the hardware | (as determined by the compiler); | | UPDATEIFCOPY (U) this array is a copy of some other array (referenced | by .base). When this array is deallocated, the base array will be | updated with the contents of this array. | | All flags can be accessed using their first (upper case) letter as well | as the full name. | | Examples | -------- | >>> y | array([[3, 1, 7], | [2, 0, 0], | [8, 5, 9]]) | >>> y.flags | C_CONTIGUOUS : True | F_CONTIGUOUS : False | OWNDATA : True | WRITEABLE : True | ALIGNED : True | UPDATEIFCOPY : False | >>> y.setflags(write=0, align=0) | >>> y.flags | C_CONTIGUOUS : True | F_CONTIGUOUS : False | OWNDATA : True | WRITEABLE : False | ALIGNED : False | UPDATEIFCOPY : False | >>> y.setflags(uic=1) | Traceback (most recent call last): | File "<stdin>", line 1, in <module> | ValueError: cannot set UPDATEIFCOPY flag to True | | sort(...) | a.sort(axis=-1, kind='quicksort', order=None) | | Sort an array, in-place. | | Parameters | ---------- | axis : int, optional | Axis along which to sort. Default is -1, which means sort along the | last axis. | kind : {'quicksort', 'mergesort', 'heapsort'}, optional | Sorting algorithm. Default is 'quicksort'. | order : str or list of str, optional | When `a` is an array with fields defined, this argument specifies | which fields to compare first, second, etc. A single field can | be specified as a string, and not all fields need be specified, | but unspecified fields will still be used, in the order in which | they come up in the dtype, to break ties. | | See Also | -------- | numpy.sort : Return a sorted copy of an array. | argsort : Indirect sort. | lexsort : Indirect stable sort on multiple keys. | searchsorted : Find elements in sorted array. | partition: Partial sort. | | Notes | ----- | See ``sort`` for notes on the different sorting algorithms. | | Examples | -------- | >>> a = np.array([[1,4], [3,1]]) | >>> a.sort(axis=1) | >>> a | array([[1, 4], | [1, 3]]) | >>> a.sort(axis=0) | >>> a | array([[1, 3], | [1, 4]]) | | Use the `order` keyword to specify a field to use when sorting a | structured array: | | >>> a = np.array([('a', 2), ('c', 1)], dtype=[('x', 'S1'), ('y', int)]) | >>> a.sort(order='y') | >>> a | array([('c', 1), ('a', 2)], | dtype=[('x', '|S1'), ('y', '<i4')]) | | squeeze(...) | a.squeeze(axis=None) | | Remove single-dimensional entries from the shape of `a`. | | Refer to `numpy.squeeze` for full documentation. | | See Also | -------- | numpy.squeeze : equivalent function | | std(...) | a.std(axis=None, dtype=None, out=None, ddof=0, keepdims=False) | | Returns the standard deviation of the array elements along given axis. | | Refer to `numpy.std` for full documentation. | | See Also | -------- | numpy.std : equivalent function | | sum(...) | a.sum(axis=None, dtype=None, out=None, keepdims=False) | | Return the sum of the array elements over the given axis. | | Refer to `numpy.sum` for full documentation. | | See Also | -------- | numpy.sum : equivalent function | | swapaxes(...) | a.swapaxes(axis1, axis2) | | Return a view of the array with `axis1` and `axis2` interchanged. | | Refer to `numpy.swapaxes` for full documentation. | | See Also | -------- | numpy.swapaxes : equivalent function | | take(...) | a.take(indices, axis=None, out=None, mode='raise') | | Return an array formed from the elements of `a` at the given indices. | | Refer to `numpy.take` for full documentation. | | See Also | -------- | numpy.take : equivalent function | | tobytes(...) | a.tobytes(order='C') | | Construct Python bytes containing the raw data bytes in the array. | | Constructs Python bytes showing a copy of the raw contents of | data memory. The bytes object can be produced in either 'C' or 'Fortran', | or 'Any' order (the default is 'C'-order). 'Any' order means C-order | unless the F_CONTIGUOUS flag in the array is set, in which case it | means 'Fortran' order. | | .. versionadded:: 1.9.0 | | Parameters | ---------- | order : {'C', 'F', None}, optional | Order of the data for multidimensional arrays: | C, Fortran, or the same as for the original array. | | Returns | ------- | s : bytes | Python bytes exhibiting a copy of `a`'s raw data. | | Examples | -------- | >>> x = np.array([[0, 1], [2, 3]]) | >>> x.tobytes() | b'\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00' | >>> x.tobytes('C') == x.tobytes() | True | >>> x.tobytes('F') | b'\x00\x00\x00\x00\x02\x00\x00\x00\x01\x00\x00\x00\x03\x00\x00\x00' | | tofile(...) | a.tofile(fid, sep="", format="%s") | | Write array to a file as text or binary (default). | | Data is always written in 'C' order, independent of the order of `a`. | The data produced by this method can be recovered using the function | fromfile(). | | Parameters | ---------- | fid : file or str | An open file object, or a string containing a filename. | sep : str | Separator between array items for text output. | If "" (empty), a binary file is written, equivalent to | ``file.write(a.tobytes())``. | format : str | Format string for text file output. | Each entry in the array is formatted to text by first converting | it to the closest Python type, and then using "format" % item. | | Notes | ----- | This is a convenience function for quick storage of array data. | Information on endianness and precision is lost, so this method is not a | good choice for files intended to archive data or transport data between | machines with different endianness. Some of these problems can be overcome | by outputting the data as text files, at the expense of speed and file | size. | | tolist(...) | a.tolist() | | Return the array as a (possibly nested) list. | | Return a copy of the array data as a (nested) Python list. | Data items are converted to the nearest compatible Python type. | | Parameters | ---------- | none | | Returns | ------- | y : list | The possibly nested list of array elements. | | Notes | ----- | The array may be recreated, ``a = np.array(a.tolist())``. | | Examples | -------- | >>> a = np.array([1, 2]) | >>> a.tolist() | [1, 2] | >>> a = np.array([[1, 2], [3, 4]]) | >>> list(a) | [array([1, 2]), array([3, 4])] | >>> a.tolist() | [[1, 2], [3, 4]] | | tostring(...) | a.tostring(order='C') | | Construct Python bytes containing the raw data bytes in the array. | | Constructs Python bytes showing a copy of the raw contents of | data memory. The bytes object can be produced in either 'C' or 'Fortran', | or 'Any' order (the default is 'C'-order). 'Any' order means C-order | unless the F_CONTIGUOUS flag in the array is set, in which case it | means 'Fortran' order. | | This function is a compatibility alias for tobytes. Despite its name it returns bytes not strings. | | Parameters | ---------- | order : {'C', 'F', None}, optional | Order of the data for multidimensional arrays: | C, Fortran, or the same as for the original array. | | Returns | ------- | s : bytes | Python bytes exhibiting a copy of `a`'s raw data. | | Examples | -------- | >>> x = np.array([[0, 1], [2, 3]]) | >>> x.tobytes() | b'\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00' | >>> x.tobytes('C') == x.tobytes() | True | >>> x.tobytes('F') | b'\x00\x00\x00\x00\x02\x00\x00\x00\x01\x00\x00\x00\x03\x00\x00\x00' | | trace(...) | a.trace(offset=0, axis1=0, axis2=1, dtype=None, out=None) | | Return the sum along diagonals of the array. | | Refer to `numpy.trace` for full documentation. | | See Also | -------- | numpy.trace : equivalent function | | transpose(...) | a.transpose(*axes) | | Returns a view of the array with axes transposed. | | For a 1-D array, this has no effect. (To change between column and | row vectors, first cast the 1-D array into a matrix object.) | For a 2-D array, this is the usual matrix transpose. | For an n-D array, if axes are given, their order indicates how the | axes are permuted (see Examples). If axes are not provided and | ``a.shape = (i[0], i[1], ... i[n-2], i[n-1])``, then | ``a.transpose().shape = (i[n-1], i[n-2], ... i[1], i[0])``. | | Parameters | ---------- | axes : None, tuple of ints, or `n` ints | | * None or no argument: reverses the order of the axes. | | * tuple of ints: `i` in the `j`-th place in the tuple means `a`'s | `i`-th axis becomes `a.transpose()`'s `j`-th axis. | | * `n` ints: same as an n-tuple of the same ints (this form is | intended simply as a "convenience" alternative to the tuple form) | | Returns | ------- | out : ndarray | View of `a`, with axes suitably permuted. | | See Also | -------- | ndarray.T : Array property returning the array transposed. | | Examples | -------- | >>> a = np.array([[1, 2], [3, 4]]) | >>> a | array([[1, 2], | [3, 4]]) | >>> a.transpose() | array([[1, 3], | [2, 4]]) | >>> a.transpose((1, 0)) | array([[1, 3], | [2, 4]]) | >>> a.transpose(1, 0) | array([[1, 3], | [2, 4]]) | | var(...) | a.var(axis=None, dtype=None, out=None, ddof=0, keepdims=False) | | Returns the variance of the array elements, along given axis. | | Refer to `numpy.var` for full documentation. | | See Also | -------- | numpy.var : equivalent function | | view(...) | a.view(dtype=None, type=None) | | New view of array with the same data. | | Parameters | ---------- | dtype : data-type or ndarray sub-class, optional | Data-type descriptor of the returned view, e.g., float32 or int16. The | default, None, results in the view having the same data-type as `a`. | This argument can also be specified as an ndarray sub-class, which | then specifies the type of the returned object (this is equivalent to | setting the ``type`` parameter). | type : Python type, optional | Type of the returned view, e.g., ndarray or matrix. Again, the | default None results in type preservation. | | Notes | ----- | ``a.view()`` is used two different ways: | | ``a.view(some_dtype)`` or ``a.view(dtype=some_dtype)`` constructs a view | of the array's memory with a different data-type. This can cause a | reinterpretation of the bytes of memory. | | ``a.view(ndarray_subclass)`` or ``a.view(type=ndarray_subclass)`` just | returns an instance of `ndarray_subclass` that looks at the same array | (same shape, dtype, etc.) This does not cause a reinterpretation of the | memory. | | For ``a.view(some_dtype)``, if ``some_dtype`` has a different number of | bytes per entry than the previous dtype (for example, converting a | regular array to a structured array), then the behavior of the view | cannot be predicted just from the superficial appearance of ``a`` (shown | by ``print(a)``). It also depends on exactly how ``a`` is stored in | memory. Therefore if ``a`` is C-ordered versus fortran-ordered, versus | defined as a slice or transpose, etc., the view may give different | results. | | | Examples | -------- | >>> x = np.array([(1, 2)], dtype=[('a', np.int8), ('b', np.int8)]) | | Viewing array data using a different type and dtype: | | >>> y = x.view(dtype=np.int16, type=np.matrix) | >>> y | matrix([[513]], dtype=int16) | >>> print type(y) | <class 'numpy.matrixlib.defmatrix.matrix'> | | Creating a view on a structured array so it can be used in calculations | | >>> x = np.array([(1, 2),(3,4)], dtype=[('a', np.int8), ('b', np.int8)]) | >>> xv = x.view(dtype=np.int8).reshape(-1,2) | >>> xv | array([[1, 2], | [3, 4]], dtype=int8) | >>> xv.mean(0) | array([ 2., 3.]) | | Making changes to the view changes the underlying array | | >>> xv[0,1] = 20 | >>> print x | [(1, 20) (3, 4)] | | Using a view to convert an array to a recarray: | | >>> z = x.view(np.recarray) | >>> z.a | array([1], dtype=int8) | | Views share data: | | >>> x[0] = (9, 10) | >>> z[0] | (9, 10) | | Views that change the dtype size (bytes per entry) should normally be | avoided on arrays defined by slices, transposes, fortran-ordering, etc.: | | >>> x = np.array([[1,2,3],[4,5,6]], dtype=np.int16) | >>> y = x[:, 0:2] | >>> y | array([[1, 2], | [4, 5]], dtype=int16) | >>> y.view(dtype=[('width', np.int16), ('length', np.int16)]) | Traceback (most recent call last): | File "<stdin>", line 1, in <module> | ValueError: new type not compatible with array. | >>> z = y.copy() | >>> z.view(dtype=[('width', np.int16), ('length', np.int16)]) | array([[(1, 2)], | [(4, 5)]], dtype=[('width', '<i2'), ('length', '<i2')]) | | ---------------------------------------------------------------------- | Data descriptors inherited from ndarray: | | T | Same as self.transpose(), except that self is returned if | self.ndim < 2. | | Examples | -------- | >>> x = np.array([[1.,2.],[3.,4.]]) | >>> x | array([[ 1., 2.], | [ 3., 4.]]) | >>> x.T | array([[ 1., 3.], | [ 2., 4.]]) | >>> x = np.array([1.,2.,3.,4.]) | >>> x | array([ 1., 2., 3., 4.]) | >>> x.T | array([ 1., 2., 3., 4.]) | | __array_interface__ | Array protocol: Python side. | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: C-struct side. | | base | Base object if memory is from some other object. | | Examples | -------- | The base of an array that owns its memory is None: | | >>> x = np.array([1,2,3,4]) | >>> x.base is None | True | | Slicing creates a view, whose memory is shared with x: | | >>> y = x[2:] | >>> y.base is x | True | | ctypes | An object to simplify the interaction of the array with the ctypes | module. | | This attribute creates an object that makes it easier to use arrays | when calling shared libraries with the ctypes module. The returned | object has, among others, data, shape, and strides attributes (see | Notes below) which themselves return ctypes objects that can be used | as arguments to a shared library. | | Parameters | ---------- | None | | Returns | ------- | c : Python object | Possessing attributes data, shape, strides, etc. | | See Also | -------- | numpy.ctypeslib | | Notes | ----- | Below are the public attributes of this object which were documented | in "Guide to NumPy" (we have omitted undocumented public attributes, | as well as documented private attributes): | | * data: A pointer to the memory area of the array as a Python integer. | This memory area may contain data that is not aligned, or not in correct | byte-order. The memory area may not even be writeable. The array | flags and data-type of this array should be respected when passing this | attribute to arbitrary C-code to avoid trouble that can include Python | crashing. User Beware! The value of this attribute is exactly the same | as self._array_interface_['data'][0]. | | * shape (c_intp*self.ndim): A ctypes array of length self.ndim where | the basetype is the C-integer corresponding to dtype('p') on this | platform. This base-type could be c_int, c_long, or c_longlong | depending on the platform. The c_intp type is defined accordingly in | numpy.ctypeslib. The ctypes array contains the shape of the underlying | array. | | * strides (c_intp*self.ndim): A ctypes array of length self.ndim where | the basetype is the same as for the shape attribute. This ctypes array | contains the strides information from the underlying array. This strides | information is important for showing how many bytes must be jumped to | get to the next element in the array. | | * data_as(obj): Return the data pointer cast to a particular c-types object. | For example, calling self._as_parameter_ is equivalent to | self.data_as(ctypes.c_void_p). Perhaps you want to use the data as a | pointer to a ctypes array of floating-point data: | self.data_as(ctypes.POINTER(ctypes.c_double)). | | * shape_as(obj): Return the shape tuple as an array of some other c-types | type. For example: self.shape_as(ctypes.c_short). | | * strides_as(obj): Return the strides tuple as an array of some other | c-types type. For example: self.strides_as(ctypes.c_longlong). | | Be careful using the ctypes attribute - especially on temporary | arrays or arrays constructed on the fly. For example, calling | ``(a+b).ctypes.data_as(ctypes.c_void_p)`` returns a pointer to memory | that is invalid because the array created as (a+b) is deallocated | before the next Python statement. You can avoid this problem using | either ``c=a+b`` or ``ct=(a+b).ctypes``. In the latter case, ct will | hold a reference to the array until ct is deleted or re-assigned. | | If the ctypes module is not available, then the ctypes attribute | of array objects still returns something useful, but ctypes objects | are not returned and errors may be raised instead. In particular, | the object will still have the as parameter attribute which will | return an integer equal to the data attribute. | | Examples | -------- | >>> import ctypes | >>> x | array([[0, 1], | [2, 3]]) | >>> x.ctypes.data | 30439712 | >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_long)) | <ctypes.LP_c_long object at 0x01F01300> | >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_long)).contents | c_long(0) | >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_longlong)).contents | c_longlong(4294967296L) | >>> x.ctypes.shape | <numpy.core._internal.c_long_Array_2 object at 0x01FFD580> | >>> x.ctypes.shape_as(ctypes.c_long) | <numpy.core._internal.c_long_Array_2 object at 0x01FCE620> | >>> x.ctypes.strides | <numpy.core._internal.c_long_Array_2 object at 0x01FCE620> | >>> x.ctypes.strides_as(ctypes.c_longlong) | <numpy.core._internal.c_longlong_Array_2 object at 0x01F01300> | | data | Python buffer object pointing to the start of the array's data. | | dtype | Data-type of the array's elements. | | Parameters | ---------- | None | | Returns | ------- | d : numpy dtype object | | See Also | -------- | numpy.dtype | | Examples | -------- | >>> x | array([[0, 1], | [2, 3]]) | >>> x.dtype | dtype('int32') | >>> type(x.dtype) | <type 'numpy.dtype'> | | flags | Information about the memory layout of the array. | | Attributes | ---------- | C_CONTIGUOUS (C) | The data is in a single, C-style contiguous segment. | F_CONTIGUOUS (F) | The data is in a single, Fortran-style contiguous segment. | OWNDATA (O) | The array owns the memory it uses or borrows it from another object. | WRITEABLE (W) | The data area can be written to. Setting this to False locks | the data, making it read-only. A view (slice, etc.) inherits WRITEABLE | from its base array at creation time, but a view of a writeable | array may be subsequently locked while the base array remains writeable. | (The opposite is not true, in that a view of a locked array may not | be made writeable. However, currently, locking a base object does not | lock any views that already reference it, so under that circumstance it | is possible to alter the contents of a locked array via a previously | created writeable view onto it.) Attempting to change a non-writeable | array raises a RuntimeError exception. | ALIGNED (A) | The data and all elements are aligned appropriately for the hardware. | UPDATEIFCOPY (U) | This array is a copy of some other array. When this array is | deallocated, the base array will be updated with the contents of | this array. | FNC | F_CONTIGUOUS and not C_CONTIGUOUS. | FORC | F_CONTIGUOUS or C_CONTIGUOUS (one-segment test). | BEHAVED (B) | ALIGNED and WRITEABLE. | CARRAY (CA) | BEHAVED and C_CONTIGUOUS. | FARRAY (FA) | BEHAVED and F_CONTIGUOUS and not C_CONTIGUOUS. | | Notes | ----- | The `flags` object can be accessed dictionary-like (as in ``a.flags['WRITEABLE']``), | or by using lowercased attribute names (as in ``a.flags.writeable``). Short flag | names are only supported in dictionary access. | | Only the UPDATEIFCOPY, WRITEABLE, and ALIGNED flags can be changed by | the user, via direct assignment to the attribute or dictionary entry, | or by calling `ndarray.setflags`. | | The array flags cannot be set arbitrarily: | | - UPDATEIFCOPY can only be set ``False``. | - ALIGNED can only be set ``True`` if the data is truly aligned. | - WRITEABLE can only be set ``True`` if the array owns its own memory | or the ultimate owner of the memory exposes a writeable buffer | interface or is a string. | | Arrays can be both C-style and Fortran-style contiguous simultaneously. | This is clear for 1-dimensional arrays, but can also be true for higher | dimensional arrays. | | Even for contiguous arrays a stride for a given dimension | ``arr.strides[dim]`` may be *arbitrary* if ``arr.shape[dim] == 1`` | or the array has no elements. | It does *not* generally hold that ``self.strides[-1] == self.itemsize`` | for C-style contiguous arrays or ``self.strides[0] == self.itemsize`` for | Fortran-style contiguous arrays is true. | | flat | A 1-D iterator over the array. | | This is a `numpy.flatiter` instance, which acts similarly to, but is not | a subclass of, Python's built-in iterator object. | | See Also | -------- | flatten : Return a copy of the array collapsed into one dimension. | | flatiter | | Examples | -------- | >>> x = np.arange(1, 7).reshape(2, 3) | >>> x | array([[1, 2, 3], | [4, 5, 6]]) | >>> x.flat[3] | 4 | >>> x.T | array([[1, 4], | [2, 5], | [3, 6]]) | >>> x.T.flat[3] | 5 | >>> type(x.flat) | <type 'numpy.flatiter'> | | An assignment example: | | >>> x.flat = 3; x | array([[3, 3, 3], | [3, 3, 3]]) | >>> x.flat[[1,4]] = 1; x | array([[3, 1, 3], | [3, 1, 3]]) | | imag | The imaginary part of the array. | | Examples | -------- | >>> x = np.sqrt([1+0j, 0+1j]) | >>> x.imag | array([ 0. , 0.70710678]) | >>> x.imag.dtype | dtype('float64') | | itemsize | Length of one array element in bytes. | | Examples | -------- | >>> x = np.array([1,2,3], dtype=np.float64) | >>> x.itemsize | 8 | >>> x = np.array([1,2,3], dtype=np.complex128) | >>> x.itemsize | 16 | | nbytes | Total bytes consumed by the elements of the array. | | Notes | ----- | Does not include memory consumed by non-element attributes of the | array object. | | Examples | -------- | >>> x = np.zeros((3,5,2), dtype=np.complex128) | >>> x.nbytes | 480 | >>> np.prod(x.shape) * x.itemsize | 480 | | 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 | The real part of the array. | | Examples | -------- | >>> x = np.sqrt([1+0j, 0+1j]) | >>> x.real | array([ 1. , 0.70710678]) | >>> x.real.dtype | dtype('float64') | | See Also | -------- | numpy.real : equivalent function | | shape | Tuple of array dimensions. | | Notes | ----- | May be used to "reshape" the array, as long as this would not | require a change in the total number of elements | | Examples | -------- | >>> x = np.array([1, 2, 3, 4]) | >>> x.shape | (4,) | >>> y = np.zeros((2, 3, 4)) | >>> y.shape | (2, 3, 4) | >>> y.shape = (3, 8) | >>> y | array([[ 0., 0., 0., 0., 0., 0., 0., 0.], | [ 0., 0., 0., 0., 0., 0., 0., 0.], | [ 0., 0., 0., 0., 0., 0., 0., 0.]]) | >>> y.shape = (3, 6) | Traceback (most recent call last): | File "<stdin>", line 1, in <module> | ValueError: total size of new array must be unchanged | | size | Number of elements in the array. | | Equivalent to ``np.prod(a.shape)``, i.e., the product of the array's | dimensions. | | Examples | -------- | >>> x = np.zeros((3, 5, 2), dtype=np.complex128) | >>> x.size | 30 | >>> np.prod(x.shape) | 30 | | strides | Tuple of bytes to step in each dimension when traversing an array. | | The byte offset of element ``(i[0], i[1], ..., i[n])`` in an array `a` | is:: | | offset = sum(np.array(i) * a.strides) | | A more detailed explanation of strides can be found in the | "ndarray.rst" file in the NumPy reference guide. | | Notes | ----- | Imagine an array of 32-bit integers (each 4 bytes):: | | x = np.array([[0, 1, 2, 3, 4], | [5, 6, 7, 8, 9]], dtype=np.int32) | | This array is stored in memory as 40 bytes, one after the other | (known as a contiguous block of memory). The strides of an array tell | us how many bytes we have to skip in memory to move to the next position | along a certain axis. For example, we have to skip 4 bytes (1 value) to | move to the next column, but 20 bytes (5 values) to get to the same | position in the next row. As such, the strides for the array `x` will be | ``(20, 4)``. | | See Also | -------- | numpy.lib.stride_tricks.as_strided | | Examples | -------- | >>> y = np.reshape(np.arange(2*3*4), (2,3,4)) | >>> y | array([[[ 0, 1, 2, 3], | [ 4, 5, 6, 7], | [ 8, 9, 10, 11]], | [[12, 13, 14, 15], | [16, 17, 18, 19], | [20, 21, 22, 23]]]) | >>> y.strides | (48, 16, 4) | >>> y[1,1,1] | 17 | >>> offset=sum(y.strides * np.array((1,1,1))) | >>> offset/y.itemsize | 17 | | >>> x = np.reshape(np.arange(5*6*7*8), (5,6,7,8)).transpose(2,3,1,0) | >>> x.strides | (32, 4, 224, 1344) | >>> i = np.array([3,5,2,2]) | >>> offset = sum(i * x.strides) | >>> x[3,5,2,2] | 813 | >>> offset / x.itemsize | 813 | | ---------------------------------------------------------------------- | Data and other attributes inherited from ndarray: | | __hash__ = None class record(void) | A data-type scalar that allows field access as attribute lookup. | | Method resolution order: | record | void | flexible | generic | __builtin__.object | | Methods defined here: | | __getattribute__(self, attr) | | __getitem__(self, indx) | | __repr__(self) | | __setattr__(self, attr, val) | | __str__(self) | | pprint(self) | Pretty-print all fields. | | ---------------------------------------------------------------------- | Data descriptors defined here: | | __dict__ | dictionary for instance variables (if defined) | | __weakref__ | list of weak references to the object (if defined) | | ---------------------------------------------------------------------- | Methods inherited from void: | | __delitem__(...) | x.__delitem__(y) <==> del x[y] | | __eq__(...) | x.__eq__(y) <==> x==y | | __ge__(...) | x.__ge__(y) <==> x>=y | | __gt__(...) | x.__gt__(y) <==> x>y | | __hash__(...) | x.__hash__() <==> hash(x) | | __le__(...) | x.__le__(y) <==> x<=y | | __len__(...) | x.__len__() <==> len(x) | | __lt__(...) | x.__lt__(y) <==> x<y | | __ne__(...) | x.__ne__(y) <==> x!=y | | __setitem__(...) | x.__setitem__(i, y) <==> x[i]=y | | getfield(...) | | setfield(...) | | ---------------------------------------------------------------------- | Data descriptors inherited from void: | | dtype | dtype object | | flags | integer value of flags | | ---------------------------------------------------------------------- | Data and other attributes inherited from void: | | __new__ = <built-in method __new__ of type object> | T.__new__(S, ...) -> a new object with type S, a subtype of T | | ---------------------------------------------------------------------- | Methods inherited from generic: | | __abs__(...) | x.__abs__() <==> abs(x) | | __add__(...) | x.__add__(y) <==> x+y | | __and__(...) | x.__and__(y) <==> x&y | | __array__(...) | sc.__array__(|type) return 0-dim array | | __array_wrap__(...) | sc.__array_wrap__(obj) return scalar from array | | __copy__(...) | | __deepcopy__(...) | | __div__(...) | x.__div__(y) <==> x/y | | __divmod__(...) | x.__divmod__(y) <==> divmod(x, y) | | __float__(...) | x.__float__() <==> float(x) | | __floordiv__(...) | x.__floordiv__(y) <==> x//y | | __format__(...) | NumPy array scalar formatter | | __hex__(...) | x.__hex__() <==> hex(x) | | __int__(...) | x.__int__() <==> int(x) | | __invert__(...) | x.__invert__() <==> ~x | | __long__(...) | x.__long__() <==> long(x) | | __lshift__(...) | x.__lshift__(y) <==> x<<y | | __mod__(...) | x.__mod__(y) <==> x%y | | __mul__(...) | x.__mul__(y) <==> x*y | | __neg__(...) | x.__neg__() <==> -x | | __nonzero__(...) | x.__nonzero__() <==> x != 0 | | __oct__(...) | x.__oct__() <==> oct(x) | | __or__(...) | x.__or__(y) <==> x|y | | __pos__(...) | x.__pos__() <==> +x | | __pow__(...) | x.__pow__(y[, z]) <==> pow(x, y[, z]) | | __radd__(...) | x.__radd__(y) <==> y+x | | __rand__(...) | x.__rand__(y) <==> y&x | | __rdiv__(...) | x.__rdiv__(y) <==> y/x | | __rdivmod__(...) | x.__rdivmod__(y) <==> divmod(y, x) | | __reduce__(...) | | __rfloordiv__(...) | x.__rfloordiv__(y) <==> y//x | | __rlshift__(...) | x.__rlshift__(y) <==> y<<x | | __rmod__(...) | x.__rmod__(y) <==> y%x | | __rmul__(...) | x.__rmul__(y) <==> y*x | | __ror__(...) | x.__ror__(y) <==> y|x | | __rpow__(...) | y.__rpow__(x[, z]) <==> pow(x, y[, z]) | | __rrshift__(...) | x.__rrshift__(y) <==> y>>x | | __rshift__(...) | x.__rshift__(y) <==> x>>y | | __rsub__(...) | x.__rsub__(y) <==> y-x | | __rtruediv__(...) | x.__rtruediv__(y) <==> y/x | | __rxor__(...) | x.__rxor__(y) <==> y^x | | __setstate__(...) | | __sizeof__(...) | | __sub__(...) | x.__sub__(y) <==> x-y | | __truediv__(...) | x.__truediv__(y) <==> x/y | | __xor__(...) | x.__xor__(y) <==> x^y | | all(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | base | base object | | data | pointer to start of data | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension short = class int16(signedinteger) | 16-bit integer. Character code ``h``. C short compatible. | | Method resolution order: | int16 | signedinteger | integer | number | generic | __builtin__.object | | Methods defined here: | | __eq__(...) | x.__eq__(y) <==> x==y | | __ge__(...) | x.__ge__(y) <==> x>=y | | __gt__(...) | x.__gt__(y) <==> x>y | | __hash__(...) | x.__hash__() <==> hash(x) | | __index__(...) | x[y:z] <==> x[y.__index__():z.__index__()] | | __le__(...) | x.__le__(y) <==> x<=y | | __lt__(...) | x.__lt__(y) <==> x<y | | __ne__(...) | x.__ne__(y) <==> x!=y | | ---------------------------------------------------------------------- | Data and other attributes defined here: | | __new__ = <built-in method __new__ of type object> | T.__new__(S, ...) -> a new object with type S, a subtype of T | | ---------------------------------------------------------------------- | Data descriptors inherited from integer: | | denominator | denominator of value (1) | | numerator | numerator of value (the value itself) | | ---------------------------------------------------------------------- | Methods inherited from generic: | | __abs__(...) | x.__abs__() <==> abs(x) | | __add__(...) | x.__add__(y) <==> x+y | | __and__(...) | x.__and__(y) <==> x&y | | __array__(...) | sc.__array__(|type) return 0-dim array | | __array_wrap__(...) | sc.__array_wrap__(obj) return scalar from array | | __copy__(...) | | __deepcopy__(...) | | __div__(...) | x.__div__(y) <==> x/y | | __divmod__(...) | x.__divmod__(y) <==> divmod(x, y) | | __float__(...) | x.__float__() <==> float(x) | | __floordiv__(...) | x.__floordiv__(y) <==> x//y | | __format__(...) | NumPy array scalar formatter | | __getitem__(...) | x.__getitem__(y) <==> x[y] | | __hex__(...) | x.__hex__() <==> hex(x) | | __int__(...) | x.__int__() <==> int(x) | | __invert__(...) | x.__invert__() <==> ~x | | __long__(...) | x.__long__() <==> long(x) | | __lshift__(...) | x.__lshift__(y) <==> x<<y | | __mod__(...) | x.__mod__(y) <==> x%y | | __mul__(...) | x.__mul__(y) <==> x*y | | __neg__(...) | x.__neg__() <==> -x | | __nonzero__(...) | x.__nonzero__() <==> x != 0 | | __oct__(...) | x.__oct__() <==> oct(x) | | __or__(...) | x.__or__(y) <==> x|y | | __pos__(...) | x.__pos__() <==> +x | | __pow__(...) | x.__pow__(y[, z]) <==> pow(x, y[, z]) | | __radd__(...) | x.__radd__(y) <==> y+x | | __rand__(...) | x.__rand__(y) <==> y&x | | __rdiv__(...) | x.__rdiv__(y) <==> y/x | | __rdivmod__(...) | x.__rdivmod__(y) <==> divmod(y, x) | | __reduce__(...) | | __repr__(...) | x.__repr__() <==> repr(x) | | __rfloordiv__(...) | x.__rfloordiv__(y) <==> y//x | | __rlshift__(...) | x.__rlshift__(y) <==> y<<x | | __rmod__(...) | x.__rmod__(y) <==> y%x | | __rmul__(...) | x.__rmul__(y) <==> y*x | | __ror__(...) | x.__ror__(y) <==> y|x | | __rpow__(...) | y.__rpow__(x[, z]) <==> pow(x, y[, z]) | | __rrshift__(...) | x.__rrshift__(y) <==> y>>x | | __rshift__(...) | x.__rshift__(y) <==> x>>y | | __rsub__(...) | x.__rsub__(y) <==> y-x | | __rtruediv__(...) | x.__rtruediv__(y) <==> y/x | | __rxor__(...) | x.__rxor__(y) <==> y^x | | __setstate__(...) | | __sizeof__(...) | | __str__(...) | x.__str__() <==> str(x) | | __sub__(...) | x.__sub__(y) <==> x-y | | __truediv__(...) | x.__truediv__(y) <==> x/y | | __xor__(...) | x.__xor__(y) <==> x^y | | all(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | getfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | setfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | base | base object | | data | pointer to start of data | | dtype | get array data-descriptor | | flags | integer value of flags | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension class signedinteger(integer) | Method resolution order: | signedinteger | integer | number | generic | __builtin__.object | | Data descriptors inherited from integer: | | denominator | denominator of value (1) | | numerator | numerator of value (the value itself) | | ---------------------------------------------------------------------- | Methods inherited from generic: | | __abs__(...) | x.__abs__() <==> abs(x) | | __add__(...) | x.__add__(y) <==> x+y | | __and__(...) | x.__and__(y) <==> x&y | | __array__(...) | sc.__array__(|type) return 0-dim array | | __array_wrap__(...) | sc.__array_wrap__(obj) return scalar from array | | __copy__(...) | | __deepcopy__(...) | | __div__(...) | x.__div__(y) <==> x/y | | __divmod__(...) | x.__divmod__(y) <==> divmod(x, y) | | __eq__(...) | x.__eq__(y) <==> x==y | | __float__(...) | x.__float__() <==> float(x) | | __floordiv__(...) | x.__floordiv__(y) <==> x//y | | __format__(...) | NumPy array scalar formatter | | __ge__(...) | x.__ge__(y) <==> x>=y | | __getitem__(...) | x.__getitem__(y) <==> x[y] | | __gt__(...) | x.__gt__(y) <==> x>y | | __hex__(...) | x.__hex__() <==> hex(x) | | __int__(...) | x.__int__() <==> int(x) | | __invert__(...) | x.__invert__() <==> ~x | | __le__(...) | x.__le__(y) <==> x<=y | | __long__(...) | x.__long__() <==> long(x) | | __lshift__(...) | x.__lshift__(y) <==> x<<y | | __lt__(...) | x.__lt__(y) <==> x<y | | __mod__(...) | x.__mod__(y) <==> x%y | | __mul__(...) | x.__mul__(y) <==> x*y | | __ne__(...) | x.__ne__(y) <==> x!=y | | __neg__(...) | x.__neg__() <==> -x | | __nonzero__(...) | x.__nonzero__() <==> x != 0 | | __oct__(...) | x.__oct__() <==> oct(x) | | __or__(...) | x.__or__(y) <==> x|y | | __pos__(...) | x.__pos__() <==> +x | | __pow__(...) | x.__pow__(y[, z]) <==> pow(x, y[, z]) | | __radd__(...) | x.__radd__(y) <==> y+x | | __rand__(...) | x.__rand__(y) <==> y&x | | __rdiv__(...) | x.__rdiv__(y) <==> y/x | | __rdivmod__(...) | x.__rdivmod__(y) <==> divmod(y, x) | | __reduce__(...) | | __repr__(...) | x.__repr__() <==> repr(x) | | __rfloordiv__(...) | x.__rfloordiv__(y) <==> y//x | | __rlshift__(...) | x.__rlshift__(y) <==> y<<x | | __rmod__(...) | x.__rmod__(y) <==> y%x | | __rmul__(...) | x.__rmul__(y) <==> y*x | | __ror__(...) | x.__ror__(y) <==> y|x | | __rpow__(...) | y.__rpow__(x[, z]) <==> pow(x, y[, z]) | | __rrshift__(...) | x.__rrshift__(y) <==> y>>x | | __rshift__(...) | x.__rshift__(y) <==> x>>y | | __rsub__(...) | x.__rsub__(y) <==> y-x | | __rtruediv__(...) | x.__rtruediv__(y) <==> y/x | | __rxor__(...) | x.__rxor__(y) <==> y^x | | __setstate__(...) | | __sizeof__(...) | | __str__(...) | x.__str__() <==> str(x) | | __sub__(...) | x.__sub__(y) <==> x-y | | __truediv__(...) | x.__truediv__(y) <==> x/y | | __xor__(...) | x.__xor__(y) <==> x^y | | all(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | getfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | setfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | base | base object | | data | pointer to start of data | | dtype | get array data-descriptor | | flags | integer value of flags | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension single = class float32(floating) | 32-bit floating-point number. Character code 'f'. C float compatible. | | Method resolution order: | float32 | floating | inexact | number | generic | __builtin__.object | | Methods defined here: | | __eq__(...) | x.__eq__(y) <==> x==y | | __ge__(...) | x.__ge__(y) <==> x>=y | | __gt__(...) | x.__gt__(y) <==> x>y | | __hash__(...) | x.__hash__() <==> hash(x) | | __le__(...) | x.__le__(y) <==> x<=y | | __lt__(...) | x.__lt__(y) <==> x<y | | __ne__(...) | x.__ne__(y) <==> x!=y | | __repr__(...) | x.__repr__() <==> repr(x) | | __str__(...) | x.__str__() <==> str(x) | | ---------------------------------------------------------------------- | Data and other attributes defined here: | | __new__ = <built-in method __new__ of type object> | T.__new__(S, ...) -> a new object with type S, a subtype of T | | ---------------------------------------------------------------------- | Methods inherited from generic: | | __abs__(...) | x.__abs__() <==> abs(x) | | __add__(...) | x.__add__(y) <==> x+y | | __and__(...) | x.__and__(y) <==> x&y | | __array__(...) | sc.__array__(|type) return 0-dim array | | __array_wrap__(...) | sc.__array_wrap__(obj) return scalar from array | | __copy__(...) | | __deepcopy__(...) | | __div__(...) | x.__div__(y) <==> x/y | | __divmod__(...) | x.__divmod__(y) <==> divmod(x, y) | | __float__(...) | x.__float__() <==> float(x) | | __floordiv__(...) | x.__floordiv__(y) <==> x//y | | __format__(...) | NumPy array scalar formatter | | __getitem__(...) | x.__getitem__(y) <==> x[y] | | __hex__(...) | x.__hex__() <==> hex(x) | | __int__(...) | x.__int__() <==> int(x) | | __invert__(...) | x.__invert__() <==> ~x | | __long__(...) | x.__long__() <==> long(x) | | __lshift__(...) | x.__lshift__(y) <==> x<<y | | __mod__(...) | x.__mod__(y) <==> x%y | | __mul__(...) | x.__mul__(y) <==> x*y | | __neg__(...) | x.__neg__() <==> -x | | __nonzero__(...) | x.__nonzero__() <==> x != 0 | | __oct__(...) | x.__oct__() <==> oct(x) | | __or__(...) | x.__or__(y) <==> x|y | | __pos__(...) | x.__pos__() <==> +x | | __pow__(...) | x.__pow__(y[, z]) <==> pow(x, y[, z]) | | __radd__(...) | x.__radd__(y) <==> y+x | | __rand__(...) | x.__rand__(y) <==> y&x | | __rdiv__(...) | x.__rdiv__(y) <==> y/x | | __rdivmod__(...) | x.__rdivmod__(y) <==> divmod(y, x) | | __reduce__(...) | | __rfloordiv__(...) | x.__rfloordiv__(y) <==> y//x | | __rlshift__(...) | x.__rlshift__(y) <==> y<<x | | __rmod__(...) | x.__rmod__(y) <==> y%x | | __rmul__(...) | x.__rmul__(y) <==> y*x | | __ror__(...) | x.__ror__(y) <==> y|x | | __rpow__(...) | y.__rpow__(x[, z]) <==> pow(x, y[, z]) | | __rrshift__(...) | x.__rrshift__(y) <==> y>>x | | __rshift__(...) | x.__rshift__(y) <==> x>>y | | __rsub__(...) | x.__rsub__(y) <==> y-x | | __rtruediv__(...) | x.__rtruediv__(y) <==> y/x | | __rxor__(...) | x.__rxor__(y) <==> y^x | | __setstate__(...) | | __sizeof__(...) | | __sub__(...) | x.__sub__(y) <==> x-y | | __truediv__(...) | x.__truediv__(y) <==> x/y | | __xor__(...) | x.__xor__(y) <==> x^y | | all(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | getfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | setfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | base | base object | | data | pointer to start of data | | dtype | get array data-descriptor | | flags | integer value of flags | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension singlecomplex = class complex64(complexfloating) | Composed of two 32 bit floats | | Method resolution order: | complex64 | complexfloating | inexact | number | generic | __builtin__.object | | Methods defined here: | | __complex__(...) | | __eq__(...) | x.__eq__(y) <==> x==y | | __ge__(...) | x.__ge__(y) <==> x>=y | | __gt__(...) | x.__gt__(y) <==> x>y | | __hash__(...) | x.__hash__() <==> hash(x) | | __le__(...) | x.__le__(y) <==> x<=y | | __lt__(...) | x.__lt__(y) <==> x<y | | __ne__(...) | x.__ne__(y) <==> x!=y | | __repr__(...) | x.__repr__() <==> repr(x) | | __str__(...) | x.__str__() <==> str(x) | | ---------------------------------------------------------------------- | Data and other attributes defined here: | | __new__ = <built-in method __new__ of type object> | T.__new__(S, ...) -> a new object with type S, a subtype of T | | ---------------------------------------------------------------------- | Methods inherited from generic: | | __abs__(...) | x.__abs__() <==> abs(x) | | __add__(...) | x.__add__(y) <==> x+y | | __and__(...) | x.__and__(y) <==> x&y | | __array__(...) | sc.__array__(|type) return 0-dim array | | __array_wrap__(...) | sc.__array_wrap__(obj) return scalar from array | | __copy__(...) | | __deepcopy__(...) | | __div__(...) | x.__div__(y) <==> x/y | | __divmod__(...) | x.__divmod__(y) <==> divmod(x, y) | | __float__(...) | x.__float__() <==> float(x) | | __floordiv__(...) | x.__floordiv__(y) <==> x//y | | __format__(...) | NumPy array scalar formatter | | __getitem__(...) | x.__getitem__(y) <==> x[y] | | __hex__(...) | x.__hex__() <==> hex(x) | | __int__(...) | x.__int__() <==> int(x) | | __invert__(...) | x.__invert__() <==> ~x | | __long__(...) | x.__long__() <==> long(x) | | __lshift__(...) | x.__lshift__(y) <==> x<<y | | __mod__(...) | x.__mod__(y) <==> x%y | | __mul__(...) | x.__mul__(y) <==> x*y | | __neg__(...) | x.__neg__() <==> -x | | __nonzero__(...) | x.__nonzero__() <==> x != 0 | | __oct__(...) | x.__oct__() <==> oct(x) | | __or__(...) | x.__or__(y) <==> x|y | | __pos__(...) | x.__pos__() <==> +x | | __pow__(...) | x.__pow__(y[, z]) <==> pow(x, y[, z]) | | __radd__(...) | x.__radd__(y) <==> y+x | | __rand__(...) | x.__rand__(y) <==> y&x | | __rdiv__(...) | x.__rdiv__(y) <==> y/x | | __rdivmod__(...) | x.__rdivmod__(y) <==> divmod(y, x) | | __reduce__(...) | | __rfloordiv__(...) | x.__rfloordiv__(y) <==> y//x | | __rlshift__(...) | x.__rlshift__(y) <==> y<<x | | __rmod__(...) | x.__rmod__(y) <==> y%x | | __rmul__(...) | x.__rmul__(y) <==> y*x | | __ror__(...) | x.__ror__(y) <==> y|x | | __rpow__(...) | y.__rpow__(x[, z]) <==> pow(x, y[, z]) | | __rrshift__(...) | x.__rrshift__(y) <==> y>>x | | __rshift__(...) | x.__rshift__(y) <==> x>>y | | __rsub__(...) | x.__rsub__(y) <==> y-x | | __rtruediv__(...) | x.__rtruediv__(y) <==> y/x | | __rxor__(...) | x.__rxor__(y) <==> y^x | | __setstate__(...) | | __sizeof__(...) | | __sub__(...) | x.__sub__(y) <==> x-y | | __truediv__(...) | x.__truediv__(y) <==> x/y | | __xor__(...) | x.__xor__(y) <==> x^y | | all(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | getfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | setfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | base | base object | | data | pointer to start of data | | dtype | get array data-descriptor | | flags | integer value of flags | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension str_ = class string_(__builtin__.str, character) | Method resolution order: | string_ | __builtin__.str | __builtin__.basestring | character | flexible | generic | __builtin__.object | | Methods defined here: | | __eq__(...) | x.__eq__(y) <==> x==y | | __ge__(...) | x.__ge__(y) <==> x>=y | | __gt__(...) | x.__gt__(y) <==> x>y | | __hash__(...) | x.__hash__() <==> hash(x) | | __le__(...) | x.__le__(y) <==> x<=y | | __lt__(...) | x.__lt__(y) <==> x<y | | __ne__(...) | x.__ne__(y) <==> x!=y | | __repr__(...) | x.__repr__() <==> repr(x) | | __str__(...) | x.__str__() <==> str(x) | | ---------------------------------------------------------------------- | Data and other attributes defined here: | | __new__ = <built-in method __new__ of type object> | T.__new__(S, ...) -> a new object with type S, a subtype of T | | ---------------------------------------------------------------------- | Methods inherited from __builtin__.str: | | __add__(...) | x.__add__(y) <==> x+y | | __contains__(...) | x.__contains__(y) <==> y in x | | __format__(...) | S.__format__(format_spec) -> string | | Return a formatted version of S as described by format_spec. | | __getattribute__(...) | x.__getattribute__('name') <==> x.name | | __getitem__(...) | x.__getitem__(y) <==> x[y] | | __getnewargs__(...) | | __getslice__(...) | x.__getslice__(i, j) <==> x[i:j] | | Use of negative indices is not supported. | | __len__(...) | x.__len__() <==> len(x) | | __mod__(...) | x.__mod__(y) <==> x%y | | __mul__(...) | x.__mul__(n) <==> x*n | | __rmod__(...) | x.__rmod__(y) <==> y%x | | __rmul__(...) | x.__rmul__(n) <==> n*x | | __sizeof__(...) | S.__sizeof__() -> size of S in memory, in bytes | | capitalize(...) | S.capitalize() -> string | | Return a copy of the string S with only its first character | capitalized. | | center(...) | S.center(width[, fillchar]) -> string | | Return S centered in a string of length width. Padding is | done using the specified fill character (default is a space) | | count(...) | S.count(sub[, start[, end]]) -> int | | Return the number of non-overlapping occurrences of substring sub in | string S[start:end]. Optional arguments start and end are interpreted | as in slice notation. | | decode(...) | S.decode([encoding[,errors]]) -> object | | Decodes S using the codec registered for encoding. encoding defaults | to the default encoding. errors may be given to set a different error | handling scheme. Default is 'strict' meaning that encoding errors raise | a UnicodeDecodeError. Other possible values are 'ignore' and 'replace' | as well as any other name registered with codecs.register_error that is | able to handle UnicodeDecodeErrors. | | encode(...) | S.encode([encoding[,errors]]) -> object | | Encodes S using the codec registered for encoding. encoding defaults | to the default encoding. errors may be given to set a different error | handling scheme. Default is 'strict' meaning that encoding errors raise | a UnicodeEncodeError. Other possible values are 'ignore', 'replace' and | 'xmlcharrefreplace' as well as any other name registered with | codecs.register_error that is able to handle UnicodeEncodeErrors. | | endswith(...) | S.endswith(suffix[, start[, end]]) -> bool | | Return True if S ends with the specified suffix, False otherwise. | With optional start, test S beginning at that position. | With optional end, stop comparing S at that position. | suffix can also be a tuple of strings to try. | | expandtabs(...) | S.expandtabs([tabsize]) -> string | | Return a copy of S where all tab characters are expanded using spaces. | If tabsize is not given, a tab size of 8 characters is assumed. | | find(...) | S.find(sub [,start [,end]]) -> int | | Return the lowest index in S where substring sub is found, | such that sub is contained within S[start:end]. Optional | arguments start and end are interpreted as in slice notation. | | Return -1 on failure. | | format(...) | S.format(*args, **kwargs) -> string | | Return a formatted version of S, using substitutions from args and kwargs. | The substitutions are identified by braces ('{' and '}'). | | index(...) | S.index(sub [,start [,end]]) -> int | | Like S.find() but raise ValueError when the substring is not found. | | isalnum(...) | S.isalnum() -> bool | | Return True if all characters in S are alphanumeric | and there is at least one character in S, False otherwise. | | isalpha(...) | S.isalpha() -> bool | | Return True if all characters in S are alphabetic | and there is at least one character in S, False otherwise. | | isdigit(...) | S.isdigit() -> bool | | Return True if all characters in S are digits | and there is at least one character in S, False otherwise. | | islower(...) | S.islower() -> bool | | Return True if all cased characters in S are lowercase and there is | at least one cased character in S, False otherwise. | | isspace(...) | S.isspace() -> bool | | Return True if all characters in S are whitespace | and there is at least one character in S, False otherwise. | | istitle(...) | S.istitle() -> bool | | Return True if S is a titlecased string and there is at least one | character in S, i.e. uppercase characters may only follow uncased | characters and lowercase characters only cased ones. Return False | otherwise. | | isupper(...) | S.isupper() -> bool | | Return True if all cased characters in S are uppercase and there is | at least one cased character in S, False otherwise. | | join(...) | S.join(iterable) -> string | | Return a string which is the concatenation of the strings in the | iterable. The separator between elements is S. | | ljust(...) | S.ljust(width[, fillchar]) -> string | | Return S left-justified in a string of length width. Padding is | done using the specified fill character (default is a space). | | lower(...) | S.lower() -> string | | Return a copy of the string S converted to lowercase. | | lstrip(...) | S.lstrip([chars]) -> string or unicode | | Return a copy of the string S with leading whitespace removed. | If chars is given and not None, remove characters in chars instead. | If chars is unicode, S will be converted to unicode before stripping | | partition(...) | S.partition(sep) -> (head, sep, tail) | | Search for the separator sep in S, and return the part before it, | the separator itself, and the part after it. If the separator is not | found, return S and two empty strings. | | replace(...) | S.replace(old, new[, count]) -> string | | Return a copy of string S with all occurrences of substring | old replaced by new. If the optional argument count is | given, only the first count occurrences are replaced. | | rfind(...) | S.rfind(sub [,start [,end]]) -> int | | Return the highest index in S where substring sub is found, | such that sub is contained within S[start:end]. Optional | arguments start and end are interpreted as in slice notation. | | Return -1 on failure. | | rindex(...) | S.rindex(sub [,start [,end]]) -> int | | Like S.rfind() but raise ValueError when the substring is not found. | | rjust(...) | S.rjust(width[, fillchar]) -> string | | Return S right-justified in a string of length width. Padding is | done using the specified fill character (default is a space) | | rpartition(...) | S.rpartition(sep) -> (head, sep, tail) | | Search for the separator sep in S, starting at the end of S, and return | the part before it, the separator itself, and the part after it. If the | separator is not found, return two empty strings and S. | | rsplit(...) | S.rsplit([sep [,maxsplit]]) -> list of strings | | Return a list of the words in the string S, using sep as the | delimiter string, starting at the end of the string and working | to the front. If maxsplit is given, at most maxsplit splits are | done. If sep is not specified or is None, any whitespace string | is a separator. | | rstrip(...) | S.rstrip([chars]) -> string or unicode | | Return a copy of the string S with trailing whitespace removed. | If chars is given and not None, remove characters in chars instead. | If chars is unicode, S will be converted to unicode before stripping | | split(...) | S.split([sep [,maxsplit]]) -> list of strings | | Return a list of the words in the string S, using sep as the | delimiter string. If maxsplit is given, at most maxsplit | splits are done. If sep is not specified or is None, any | whitespace string is a separator and empty strings are removed | from the result. | | splitlines(...) | S.splitlines(keepends=False) -> list of strings | | Return a list of the lines in S, breaking at line boundaries. | Line breaks are not included in the resulting list unless keepends | is given and true. | | startswith(...) | S.startswith(prefix[, start[, end]]) -> bool | | Return True if S starts with the specified prefix, False otherwise. | With optional start, test S beginning at that position. | With optional end, stop comparing S at that position. | prefix can also be a tuple of strings to try. | | strip(...) | S.strip([chars]) -> string or unicode | | Return a copy of the string S with leading and trailing | whitespace removed. | If chars is given and not None, remove characters in chars instead. | If chars is unicode, S will be converted to unicode before stripping | | swapcase(...) | S.swapcase() -> string | | Return a copy of the string S with uppercase characters | converted to lowercase and vice versa. | | title(...) | S.title() -> string | | Return a titlecased version of S, i.e. words start with uppercase | characters, all remaining cased characters have lowercase. | | translate(...) | S.translate(table [,deletechars]) -> string | | Return a copy of the string S, where all characters occurring | in the optional argument deletechars are removed, and the | remaining characters have been mapped through the given | translation table, which must be a string of length 256 or None. | If the table argument is None, no translation is applied and | the operation simply removes the characters in deletechars. | | upper(...) | S.upper() -> string | | Return a copy of the string S converted to uppercase. | | zfill(...) | S.zfill(width) -> string | | Pad a numeric string S with zeros on the left, to fill a field | of the specified width. The string S is never truncated. | | ---------------------------------------------------------------------- | Methods inherited from generic: | | __abs__(...) | x.__abs__() <==> abs(x) | | __and__(...) | x.__and__(y) <==> x&y | | __array__(...) | sc.__array__(|type) return 0-dim array | | __array_wrap__(...) | sc.__array_wrap__(obj) return scalar from array | | __copy__(...) | | __deepcopy__(...) | | __div__(...) | x.__div__(y) <==> x/y | | __divmod__(...) | x.__divmod__(y) <==> divmod(x, y) | | __float__(...) | x.__float__() <==> float(x) | | __floordiv__(...) | x.__floordiv__(y) <==> x//y | | __hex__(...) | x.__hex__() <==> hex(x) | | __int__(...) | x.__int__() <==> int(x) | | __invert__(...) | x.__invert__() <==> ~x | | __long__(...) | x.__long__() <==> long(x) | | __lshift__(...) | x.__lshift__(y) <==> x<<y | | __neg__(...) | x.__neg__() <==> -x | | __nonzero__(...) | x.__nonzero__() <==> x != 0 | | __oct__(...) | x.__oct__() <==> oct(x) | | __or__(...) | x.__or__(y) <==> x|y | | __pos__(...) | x.__pos__() <==> +x | | __pow__(...) | x.__pow__(y[, z]) <==> pow(x, y[, z]) | | __radd__(...) | x.__radd__(y) <==> y+x | | __rand__(...) | x.__rand__(y) <==> y&x | | __rdiv__(...) | x.__rdiv__(y) <==> y/x | | __rdivmod__(...) | x.__rdivmod__(y) <==> divmod(y, x) | | __reduce__(...) | | __rfloordiv__(...) | x.__rfloordiv__(y) <==> y//x | | __rlshift__(...) | x.__rlshift__(y) <==> y<<x | | __ror__(...) | x.__ror__(y) <==> y|x | | __rpow__(...) | y.__rpow__(x[, z]) <==> pow(x, y[, z]) | | __rrshift__(...) | x.__rrshift__(y) <==> y>>x | | __rshift__(...) | x.__rshift__(y) <==> x>>y | | __rsub__(...) | x.__rsub__(y) <==> y-x | | __rtruediv__(...) | x.__rtruediv__(y) <==> y/x | | __rxor__(...) | x.__rxor__(y) <==> y^x | | __setstate__(...) | | __sub__(...) | x.__sub__(y) <==> x-y | | __truediv__(...) | x.__truediv__(y) <==> x/y | | __xor__(...) | x.__xor__(y) <==> x^y | | all(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | getfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | setfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | base | base object | | data | pointer to start of data | | dtype | get array data-descriptor | | flags | integer value of flags | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension string0 = class string_(__builtin__.str, character) | Method resolution order: | string_ | __builtin__.str | __builtin__.basestring | character | flexible | generic | __builtin__.object | | Methods defined here: | | __eq__(...) | x.__eq__(y) <==> x==y | | __ge__(...) | x.__ge__(y) <==> x>=y | | __gt__(...) | x.__gt__(y) <==> x>y | | __hash__(...) | x.__hash__() <==> hash(x) | | __le__(...) | x.__le__(y) <==> x<=y | | __lt__(...) | x.__lt__(y) <==> x<y | | __ne__(...) | x.__ne__(y) <==> x!=y | | __repr__(...) | x.__repr__() <==> repr(x) | | __str__(...) | x.__str__() <==> str(x) | | ---------------------------------------------------------------------- | Data and other attributes defined here: | | __new__ = <built-in method __new__ of type object> | T.__new__(S, ...) -> a new object with type S, a subtype of T | | ---------------------------------------------------------------------- | Methods inherited from __builtin__.str: | | __add__(...) | x.__add__(y) <==> x+y | | __contains__(...) | x.__contains__(y) <==> y in x | | __format__(...) | S.__format__(format_spec) -> string | | Return a formatted version of S as described by format_spec. | | __getattribute__(...) | x.__getattribute__('name') <==> x.name | | __getitem__(...) | x.__getitem__(y) <==> x[y] | | __getnewargs__(...) | | __getslice__(...) | x.__getslice__(i, j) <==> x[i:j] | | Use of negative indices is not supported. | | __len__(...) | x.__len__() <==> len(x) | | __mod__(...) | x.__mod__(y) <==> x%y | | __mul__(...) | x.__mul__(n) <==> x*n | | __rmod__(...) | x.__rmod__(y) <==> y%x | | __rmul__(...) | x.__rmul__(n) <==> n*x | | __sizeof__(...) | S.__sizeof__() -> size of S in memory, in bytes | | capitalize(...) | S.capitalize() -> string | | Return a copy of the string S with only its first character | capitalized. | | center(...) | S.center(width[, fillchar]) -> string | | Return S centered in a string of length width. Padding is | done using the specified fill character (default is a space) | | count(...) | S.count(sub[, start[, end]]) -> int | | Return the number of non-overlapping occurrences of substring sub in | string S[start:end]. Optional arguments start and end are interpreted | as in slice notation. | | decode(...) | S.decode([encoding[,errors]]) -> object | | Decodes S using the codec registered for encoding. encoding defaults | to the default encoding. errors may be given to set a different error | handling scheme. Default is 'strict' meaning that encoding errors raise | a UnicodeDecodeError. Other possible values are 'ignore' and 'replace' | as well as any other name registered with codecs.register_error that is | able to handle UnicodeDecodeErrors. | | encode(...) | S.encode([encoding[,errors]]) -> object | | Encodes S using the codec registered for encoding. encoding defaults | to the default encoding. errors may be given to set a different error | handling scheme. Default is 'strict' meaning that encoding errors raise | a UnicodeEncodeError. Other possible values are 'ignore', 'replace' and | 'xmlcharrefreplace' as well as any other name registered with | codecs.register_error that is able to handle UnicodeEncodeErrors. | | endswith(...) | S.endswith(suffix[, start[, end]]) -> bool | | Return True if S ends with the specified suffix, False otherwise. | With optional start, test S beginning at that position. | With optional end, stop comparing S at that position. | suffix can also be a tuple of strings to try. | | expandtabs(...) | S.expandtabs([tabsize]) -> string | | Return a copy of S where all tab characters are expanded using spaces. | If tabsize is not given, a tab size of 8 characters is assumed. | | find(...) | S.find(sub [,start [,end]]) -> int | | Return the lowest index in S where substring sub is found, | such that sub is contained within S[start:end]. Optional | arguments start and end are interpreted as in slice notation. | | Return -1 on failure. | | format(...) | S.format(*args, **kwargs) -> string | | Return a formatted version of S, using substitutions from args and kwargs. | The substitutions are identified by braces ('{' and '}'). | | index(...) | S.index(sub [,start [,end]]) -> int | | Like S.find() but raise ValueError when the substring is not found. | | isalnum(...) | S.isalnum() -> bool | | Return True if all characters in S are alphanumeric | and there is at least one character in S, False otherwise. | | isalpha(...) | S.isalpha() -> bool | | Return True if all characters in S are alphabetic | and there is at least one character in S, False otherwise. | | isdigit(...) | S.isdigit() -> bool | | Return True if all characters in S are digits | and there is at least one character in S, False otherwise. | | islower(...) | S.islower() -> bool | | Return True if all cased characters in S are lowercase and there is | at least one cased character in S, False otherwise. | | isspace(...) | S.isspace() -> bool | | Return True if all characters in S are whitespace | and there is at least one character in S, False otherwise. | | istitle(...) | S.istitle() -> bool | | Return True if S is a titlecased string and there is at least one | character in S, i.e. uppercase characters may only follow uncased | characters and lowercase characters only cased ones. Return False | otherwise. | | isupper(...) | S.isupper() -> bool | | Return True if all cased characters in S are uppercase and there is | at least one cased character in S, False otherwise. | | join(...) | S.join(iterable) -> string | | Return a string which is the concatenation of the strings in the | iterable. The separator between elements is S. | | ljust(...) | S.ljust(width[, fillchar]) -> string | | Return S left-justified in a string of length width. Padding is | done using the specified fill character (default is a space). | | lower(...) | S.lower() -> string | | Return a copy of the string S converted to lowercase. | | lstrip(...) | S.lstrip([chars]) -> string or unicode | | Return a copy of the string S with leading whitespace removed. | If chars is given and not None, remove characters in chars instead. | If chars is unicode, S will be converted to unicode before stripping | | partition(...) | S.partition(sep) -> (head, sep, tail) | | Search for the separator sep in S, and return the part before it, | the separator itself, and the part after it. If the separator is not | found, return S and two empty strings. | | replace(...) | S.replace(old, new[, count]) -> string | | Return a copy of string S with all occurrences of substring | old replaced by new. If the optional argument count is | given, only the first count occurrences are replaced. | | rfind(...) | S.rfind(sub [,start [,end]]) -> int | | Return the highest index in S where substring sub is found, | such that sub is contained within S[start:end]. Optional | arguments start and end are interpreted as in slice notation. | | Return -1 on failure. | | rindex(...) | S.rindex(sub [,start [,end]]) -> int | | Like S.rfind() but raise ValueError when the substring is not found. | | rjust(...) | S.rjust(width[, fillchar]) -> string | | Return S right-justified in a string of length width. Padding is | done using the specified fill character (default is a space) | | rpartition(...) | S.rpartition(sep) -> (head, sep, tail) | | Search for the separator sep in S, starting at the end of S, and return | the part before it, the separator itself, and the part after it. If the | separator is not found, return two empty strings and S. | | rsplit(...) | S.rsplit([sep [,maxsplit]]) -> list of strings | | Return a list of the words in the string S, using sep as the | delimiter string, starting at the end of the string and working | to the front. If maxsplit is given, at most maxsplit splits are | done. If sep is not specified or is None, any whitespace string | is a separator. | | rstrip(...) | S.rstrip([chars]) -> string or unicode | | Return a copy of the string S with trailing whitespace removed. | If chars is given and not None, remove characters in chars instead. | If chars is unicode, S will be converted to unicode before stripping | | split(...) | S.split([sep [,maxsplit]]) -> list of strings | | Return a list of the words in the string S, using sep as the | delimiter string. If maxsplit is given, at most maxsplit | splits are done. If sep is not specified or is None, any | whitespace string is a separator and empty strings are removed | from the result. | | splitlines(...) | S.splitlines(keepends=False) -> list of strings | | Return a list of the lines in S, breaking at line boundaries. | Line breaks are not included in the resulting list unless keepends | is given and true. | | startswith(...) | S.startswith(prefix[, start[, end]]) -> bool | | Return True if S starts with the specified prefix, False otherwise. | With optional start, test S beginning at that position. | With optional end, stop comparing S at that position. | prefix can also be a tuple of strings to try. | | strip(...) | S.strip([chars]) -> string or unicode | | Return a copy of the string S with leading and trailing | whitespace removed. | If chars is given and not None, remove characters in chars instead. | If chars is unicode, S will be converted to unicode before stripping | | swapcase(...) | S.swapcase() -> string | | Return a copy of the string S with uppercase characters | converted to lowercase and vice versa. | | title(...) | S.title() -> string | | Return a titlecased version of S, i.e. words start with uppercase | characters, all remaining cased characters have lowercase. | | translate(...) | S.translate(table [,deletechars]) -> string | | Return a copy of the string S, where all characters occurring | in the optional argument deletechars are removed, and the | remaining characters have been mapped through the given | translation table, which must be a string of length 256 or None. | If the table argument is None, no translation is applied and | the operation simply removes the characters in deletechars. | | upper(...) | S.upper() -> string | | Return a copy of the string S converted to uppercase. | | zfill(...) | S.zfill(width) -> string | | Pad a numeric string S with zeros on the left, to fill a field | of the specified width. The string S is never truncated. | | ---------------------------------------------------------------------- | Methods inherited from generic: | | __abs__(...) | x.__abs__() <==> abs(x) | | __and__(...) | x.__and__(y) <==> x&y | | __array__(...) | sc.__array__(|type) return 0-dim array | | __array_wrap__(...) | sc.__array_wrap__(obj) return scalar from array | | __copy__(...) | | __deepcopy__(...) | | __div__(...) | x.__div__(y) <==> x/y | | __divmod__(...) | x.__divmod__(y) <==> divmod(x, y) | | __float__(...) | x.__float__() <==> float(x) | | __floordiv__(...) | x.__floordiv__(y) <==> x//y | | __hex__(...) | x.__hex__() <==> hex(x) | | __int__(...) | x.__int__() <==> int(x) | | __invert__(...) | x.__invert__() <==> ~x | | __long__(...) | x.__long__() <==> long(x) | | __lshift__(...) | x.__lshift__(y) <==> x<<y | | __neg__(...) | x.__neg__() <==> -x | | __nonzero__(...) | x.__nonzero__() <==> x != 0 | | __oct__(...) | x.__oct__() <==> oct(x) | | __or__(...) | x.__or__(y) <==> x|y | | __pos__(...) | x.__pos__() <==> +x | | __pow__(...) | x.__pow__(y[, z]) <==> pow(x, y[, z]) | | __radd__(...) | x.__radd__(y) <==> y+x | | __rand__(...) | x.__rand__(y) <==> y&x | | __rdiv__(...) | x.__rdiv__(y) <==> y/x | | __rdivmod__(...) | x.__rdivmod__(y) <==> divmod(y, x) | | __reduce__(...) | | __rfloordiv__(...) | x.__rfloordiv__(y) <==> y//x | | __rlshift__(...) | x.__rlshift__(y) <==> y<<x | | __ror__(...) | x.__ror__(y) <==> y|x | | __rpow__(...) | y.__rpow__(x[, z]) <==> pow(x, y[, z]) | | __rrshift__(...) | x.__rrshift__(y) <==> y>>x | | __rshift__(...) | x.__rshift__(y) <==> x>>y | | __rsub__(...) | x.__rsub__(y) <==> y-x | | __rtruediv__(...) | x.__rtruediv__(y) <==> y/x | | __rxor__(...) | x.__rxor__(y) <==> y^x | | __setstate__(...) | | __sub__(...) | x.__sub__(y) <==> x-y | | __truediv__(...) | x.__truediv__(y) <==> x/y | | __xor__(...) | x.__xor__(y) <==> x^y | | all(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | getfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | setfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | base | base object | | data | pointer to start of data | | dtype | get array data-descriptor | | flags | integer value of flags | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension class string_(__builtin__.str, character) | Method resolution order: | string_ | __builtin__.str | __builtin__.basestring | character | flexible | generic | __builtin__.object | | Methods defined here: | | __eq__(...) | x.__eq__(y) <==> x==y | | __ge__(...) | x.__ge__(y) <==> x>=y | | __gt__(...) | x.__gt__(y) <==> x>y | | __hash__(...) | x.__hash__() <==> hash(x) | | __le__(...) | x.__le__(y) <==> x<=y | | __lt__(...) | x.__lt__(y) <==> x<y | | __ne__(...) | x.__ne__(y) <==> x!=y | | __repr__(...) | x.__repr__() <==> repr(x) | | __str__(...) | x.__str__() <==> str(x) | | ---------------------------------------------------------------------- | Data and other attributes defined here: | | __new__ = <built-in method __new__ of type object> | T.__new__(S, ...) -> a new object with type S, a subtype of T | | ---------------------------------------------------------------------- | Methods inherited from __builtin__.str: | | __add__(...) | x.__add__(y) <==> x+y | | __contains__(...) | x.__contains__(y) <==> y in x | | __format__(...) | S.__format__(format_spec) -> string | | Return a formatted version of S as described by format_spec. | | __getattribute__(...) | x.__getattribute__('name') <==> x.name | | __getitem__(...) | x.__getitem__(y) <==> x[y] | | __getnewargs__(...) | | __getslice__(...) | x.__getslice__(i, j) <==> x[i:j] | | Use of negative indices is not supported. | | __len__(...) | x.__len__() <==> len(x) | | __mod__(...) | x.__mod__(y) <==> x%y | | __mul__(...) | x.__mul__(n) <==> x*n | | __rmod__(...) | x.__rmod__(y) <==> y%x | | __rmul__(...) | x.__rmul__(n) <==> n*x | | __sizeof__(...) | S.__sizeof__() -> size of S in memory, in bytes | | capitalize(...) | S.capitalize() -> string | | Return a copy of the string S with only its first character | capitalized. | | center(...) | S.center(width[, fillchar]) -> string | | Return S centered in a string of length width. Padding is | done using the specified fill character (default is a space) | | count(...) | S.count(sub[, start[, end]]) -> int | | Return the number of non-overlapping occurrences of substring sub in | string S[start:end]. Optional arguments start and end are interpreted | as in slice notation. | | decode(...) | S.decode([encoding[,errors]]) -> object | | Decodes S using the codec registered for encoding. encoding defaults | to the default encoding. errors may be given to set a different error | handling scheme. Default is 'strict' meaning that encoding errors raise | a UnicodeDecodeError. Other possible values are 'ignore' and 'replace' | as well as any other name registered with codecs.register_error that is | able to handle UnicodeDecodeErrors. | | encode(...) | S.encode([encoding[,errors]]) -> object | | Encodes S using the codec registered for encoding. encoding defaults | to the default encoding. errors may be given to set a different error | handling scheme. Default is 'strict' meaning that encoding errors raise | a UnicodeEncodeError. Other possible values are 'ignore', 'replace' and | 'xmlcharrefreplace' as well as any other name registered with | codecs.register_error that is able to handle UnicodeEncodeErrors. | | endswith(...) | S.endswith(suffix[, start[, end]]) -> bool | | Return True if S ends with the specified suffix, False otherwise. | With optional start, test S beginning at that position. | With optional end, stop comparing S at that position. | suffix can also be a tuple of strings to try. | | expandtabs(...) | S.expandtabs([tabsize]) -> string | | Return a copy of S where all tab characters are expanded using spaces. | If tabsize is not given, a tab size of 8 characters is assumed. | | find(...) | S.find(sub [,start [,end]]) -> int | | Return the lowest index in S where substring sub is found, | such that sub is contained within S[start:end]. Optional | arguments start and end are interpreted as in slice notation. | | Return -1 on failure. | | format(...) | S.format(*args, **kwargs) -> string | | Return a formatted version of S, using substitutions from args and kwargs. | The substitutions are identified by braces ('{' and '}'). | | index(...) | S.index(sub [,start [,end]]) -> int | | Like S.find() but raise ValueError when the substring is not found. | | isalnum(...) | S.isalnum() -> bool | | Return True if all characters in S are alphanumeric | and there is at least one character in S, False otherwise. | | isalpha(...) | S.isalpha() -> bool | | Return True if all characters in S are alphabetic | and there is at least one character in S, False otherwise. | | isdigit(...) | S.isdigit() -> bool | | Return True if all characters in S are digits | and there is at least one character in S, False otherwise. | | islower(...) | S.islower() -> bool | | Return True if all cased characters in S are lowercase and there is | at least one cased character in S, False otherwise. | | isspace(...) | S.isspace() -> bool | | Return True if all characters in S are whitespace | and there is at least one character in S, False otherwise. | | istitle(...) | S.istitle() -> bool | | Return True if S is a titlecased string and there is at least one | character in S, i.e. uppercase characters may only follow uncased | characters and lowercase characters only cased ones. Return False | otherwise. | | isupper(...) | S.isupper() -> bool | | Return True if all cased characters in S are uppercase and there is | at least one cased character in S, False otherwise. | | join(...) | S.join(iterable) -> string | | Return a string which is the concatenation of the strings in the | iterable. The separator between elements is S. | | ljust(...) | S.ljust(width[, fillchar]) -> string | | Return S left-justified in a string of length width. Padding is | done using the specified fill character (default is a space). | | lower(...) | S.lower() -> string | | Return a copy of the string S converted to lowercase. | | lstrip(...) | S.lstrip([chars]) -> string or unicode | | Return a copy of the string S with leading whitespace removed. | If chars is given and not None, remove characters in chars instead. | If chars is unicode, S will be converted to unicode before stripping | | partition(...) | S.partition(sep) -> (head, sep, tail) | | Search for the separator sep in S, and return the part before it, | the separator itself, and the part after it. If the separator is not | found, return S and two empty strings. | | replace(...) | S.replace(old, new[, count]) -> string | | Return a copy of string S with all occurrences of substring | old replaced by new. If the optional argument count is | given, only the first count occurrences are replaced. | | rfind(...) | S.rfind(sub [,start [,end]]) -> int | | Return the highest index in S where substring sub is found, | such that sub is contained within S[start:end]. Optional | arguments start and end are interpreted as in slice notation. | | Return -1 on failure. | | rindex(...) | S.rindex(sub [,start [,end]]) -> int | | Like S.rfind() but raise ValueError when the substring is not found. | | rjust(...) | S.rjust(width[, fillchar]) -> string | | Return S right-justified in a string of length width. Padding is | done using the specified fill character (default is a space) | | rpartition(...) | S.rpartition(sep) -> (head, sep, tail) | | Search for the separator sep in S, starting at the end of S, and return | the part before it, the separator itself, and the part after it. If the | separator is not found, return two empty strings and S. | | rsplit(...) | S.rsplit([sep [,maxsplit]]) -> list of strings | | Return a list of the words in the string S, using sep as the | delimiter string, starting at the end of the string and working | to the front. If maxsplit is given, at most maxsplit splits are | done. If sep is not specified or is None, any whitespace string | is a separator. | | rstrip(...) | S.rstrip([chars]) -> string or unicode | | Return a copy of the string S with trailing whitespace removed. | If chars is given and not None, remove characters in chars instead. | If chars is unicode, S will be converted to unicode before stripping | | split(...) | S.split([sep [,maxsplit]]) -> list of strings | | Return a list of the words in the string S, using sep as the | delimiter string. If maxsplit is given, at most maxsplit | splits are done. If sep is not specified or is None, any | whitespace string is a separator and empty strings are removed | from the result. | | splitlines(...) | S.splitlines(keepends=False) -> list of strings | | Return a list of the lines in S, breaking at line boundaries. | Line breaks are not included in the resulting list unless keepends | is given and true. | | startswith(...) | S.startswith(prefix[, start[, end]]) -> bool | | Return True if S starts with the specified prefix, False otherwise. | With optional start, test S beginning at that position. | With optional end, stop comparing S at that position. | prefix can also be a tuple of strings to try. | | strip(...) | S.strip([chars]) -> string or unicode | | Return a copy of the string S with leading and trailing | whitespace removed. | If chars is given and not None, remove characters in chars instead. | If chars is unicode, S will be converted to unicode before stripping | | swapcase(...) | S.swapcase() -> string | | Return a copy of the string S with uppercase characters | converted to lowercase and vice versa. | | title(...) | S.title() -> string | | Return a titlecased version of S, i.e. words start with uppercase | characters, all remaining cased characters have lowercase. | | translate(...) | S.translate(table [,deletechars]) -> string | | Return a copy of the string S, where all characters occurring | in the optional argument deletechars are removed, and the | remaining characters have been mapped through the given | translation table, which must be a string of length 256 or None. | If the table argument is None, no translation is applied and | the operation simply removes the characters in deletechars. | | upper(...) | S.upper() -> string | | Return a copy of the string S converted to uppercase. | | zfill(...) | S.zfill(width) -> string | | Pad a numeric string S with zeros on the left, to fill a field | of the specified width. The string S is never truncated. | | ---------------------------------------------------------------------- | Methods inherited from generic: | | __abs__(...) | x.__abs__() <==> abs(x) | | __and__(...) | x.__and__(y) <==> x&y | | __array__(...) | sc.__array__(|type) return 0-dim array | | __array_wrap__(...) | sc.__array_wrap__(obj) return scalar from array | | __copy__(...) | | __deepcopy__(...) | | __div__(...) | x.__div__(y) <==> x/y | | __divmod__(...) | x.__divmod__(y) <==> divmod(x, y) | | __float__(...) | x.__float__() <==> float(x) | | __floordiv__(...) | x.__floordiv__(y) <==> x//y | | __hex__(...) | x.__hex__() <==> hex(x) | | __int__(...) | x.__int__() <==> int(x) | | __invert__(...) | x.__invert__() <==> ~x | | __long__(...) | x.__long__() <==> long(x) | | __lshift__(...) | x.__lshift__(y) <==> x<<y | | __neg__(...) | x.__neg__() <==> -x | | __nonzero__(...) | x.__nonzero__() <==> x != 0 | | __oct__(...) | x.__oct__() <==> oct(x) | | __or__(...) | x.__or__(y) <==> x|y | | __pos__(...) | x.__pos__() <==> +x | | __pow__(...) | x.__pow__(y[, z]) <==> pow(x, y[, z]) | | __radd__(...) | x.__radd__(y) <==> y+x | | __rand__(...) | x.__rand__(y) <==> y&x | | __rdiv__(...) | x.__rdiv__(y) <==> y/x | | __rdivmod__(...) | x.__rdivmod__(y) <==> divmod(y, x) | | __reduce__(...) | | __rfloordiv__(...) | x.__rfloordiv__(y) <==> y//x | | __rlshift__(...) | x.__rlshift__(y) <==> y<<x | | __ror__(...) | x.__ror__(y) <==> y|x | | __rpow__(...) | y.__rpow__(x[, z]) <==> pow(x, y[, z]) | | __rrshift__(...) | x.__rrshift__(y) <==> y>>x | | __rshift__(...) | x.__rshift__(y) <==> x>>y | | __rsub__(...) | x.__rsub__(y) <==> y-x | | __rtruediv__(...) | x.__rtruediv__(y) <==> y/x | | __rxor__(...) | x.__rxor__(y) <==> y^x | | __setstate__(...) | | __sub__(...) | x.__sub__(y) <==> x-y | | __truediv__(...) | x.__truediv__(y) <==> x/y | | __xor__(...) | x.__xor__(y) <==> x^y | | all(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | getfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | setfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | base | base object | | data | pointer to start of data | | dtype | get array data-descriptor | | flags | integer value of flags | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension class timedelta64(signedinteger) | Method resolution order: | timedelta64 | signedinteger | integer | number | generic | __builtin__.object | | Methods defined here: | | __eq__(...) | x.__eq__(y) <==> x==y | | __ge__(...) | x.__ge__(y) <==> x>=y | | __gt__(...) | x.__gt__(y) <==> x>y | | __hash__(...) | x.__hash__() <==> hash(x) | | __le__(...) | x.__le__(y) <==> x<=y | | __lt__(...) | x.__lt__(y) <==> x<y | | __ne__(...) | x.__ne__(y) <==> x!=y | | __repr__(...) | x.__repr__() <==> repr(x) | | __str__(...) | x.__str__() <==> str(x) | | ---------------------------------------------------------------------- | Data and other attributes defined here: | | __new__ = <built-in method __new__ of type object> | T.__new__(S, ...) -> a new object with type S, a subtype of T | | ---------------------------------------------------------------------- | Data descriptors inherited from integer: | | denominator | denominator of value (1) | | numerator | numerator of value (the value itself) | | ---------------------------------------------------------------------- | Methods inherited from generic: | | __abs__(...) | x.__abs__() <==> abs(x) | | __add__(...) | x.__add__(y) <==> x+y | | __and__(...) | x.__and__(y) <==> x&y | | __array__(...) | sc.__array__(|type) return 0-dim array | | __array_wrap__(...) | sc.__array_wrap__(obj) return scalar from array | | __copy__(...) | | __deepcopy__(...) | | __div__(...) | x.__div__(y) <==> x/y | | __divmod__(...) | x.__divmod__(y) <==> divmod(x, y) | | __float__(...) | x.__float__() <==> float(x) | | __floordiv__(...) | x.__floordiv__(y) <==> x//y | | __format__(...) | NumPy array scalar formatter | | __getitem__(...) | x.__getitem__(y) <==> x[y] | | __hex__(...) | x.__hex__() <==> hex(x) | | __int__(...) | x.__int__() <==> int(x) | | __invert__(...) | x.__invert__() <==> ~x | | __long__(...) | x.__long__() <==> long(x) | | __lshift__(...) | x.__lshift__(y) <==> x<<y | | __mod__(...) | x.__mod__(y) <==> x%y | | __mul__(...) | x.__mul__(y) <==> x*y | | __neg__(...) | x.__neg__() <==> -x | | __nonzero__(...) | x.__nonzero__() <==> x != 0 | | __oct__(...) | x.__oct__() <==> oct(x) | | __or__(...) | x.__or__(y) <==> x|y | | __pos__(...) | x.__pos__() <==> +x | | __pow__(...) | x.__pow__(y[, z]) <==> pow(x, y[, z]) | | __radd__(...) | x.__radd__(y) <==> y+x | | __rand__(...) | x.__rand__(y) <==> y&x | | __rdiv__(...) | x.__rdiv__(y) <==> y/x | | __rdivmod__(...) | x.__rdivmod__(y) <==> divmod(y, x) | | __reduce__(...) | | __rfloordiv__(...) | x.__rfloordiv__(y) <==> y//x | | __rlshift__(...) | x.__rlshift__(y) <==> y<<x | | __rmod__(...) | x.__rmod__(y) <==> y%x | | __rmul__(...) | x.__rmul__(y) <==> y*x | | __ror__(...) | x.__ror__(y) <==> y|x | | __rpow__(...) | y.__rpow__(x[, z]) <==> pow(x, y[, z]) | | __rrshift__(...) | x.__rrshift__(y) <==> y>>x | | __rshift__(...) | x.__rshift__(y) <==> x>>y | | __rsub__(...) | x.__rsub__(y) <==> y-x | | __rtruediv__(...) | x.__rtruediv__(y) <==> y/x | | __rxor__(...) | x.__rxor__(y) <==> y^x | | __setstate__(...) | | __sizeof__(...) | | __sub__(...) | x.__sub__(y) <==> x-y | | __truediv__(...) | x.__truediv__(y) <==> x/y | | __xor__(...) | x.__xor__(y) <==> x^y | | all(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | getfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | setfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | base | base object | | data | pointer to start of data | | dtype | get array data-descriptor | | flags | integer value of flags | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension ubyte = class uint8(unsignedinteger) | Method resolution order: | uint8 | unsignedinteger | integer | number | generic | __builtin__.object | | Methods defined here: | | __eq__(...) | x.__eq__(y) <==> x==y | | __ge__(...) | x.__ge__(y) <==> x>=y | | __gt__(...) | x.__gt__(y) <==> x>y | | __hash__(...) | x.__hash__() <==> hash(x) | | __index__(...) | x[y:z] <==> x[y.__index__():z.__index__()] | | __le__(...) | x.__le__(y) <==> x<=y | | __lt__(...) | x.__lt__(y) <==> x<y | | __ne__(...) | x.__ne__(y) <==> x!=y | | ---------------------------------------------------------------------- | Data and other attributes defined here: | | __new__ = <built-in method __new__ of type object> | T.__new__(S, ...) -> a new object with type S, a subtype of T | | ---------------------------------------------------------------------- | Data descriptors inherited from integer: | | denominator | denominator of value (1) | | numerator | numerator of value (the value itself) | | ---------------------------------------------------------------------- | Methods inherited from generic: | | __abs__(...) | x.__abs__() <==> abs(x) | | __add__(...) | x.__add__(y) <==> x+y | | __and__(...) | x.__and__(y) <==> x&y | | __array__(...) | sc.__array__(|type) return 0-dim array | | __array_wrap__(...) | sc.__array_wrap__(obj) return scalar from array | | __copy__(...) | | __deepcopy__(...) | | __div__(...) | x.__div__(y) <==> x/y | | __divmod__(...) | x.__divmod__(y) <==> divmod(x, y) | | __float__(...) | x.__float__() <==> float(x) | | __floordiv__(...) | x.__floordiv__(y) <==> x//y | | __format__(...) | NumPy array scalar formatter | | __getitem__(...) | x.__getitem__(y) <==> x[y] | | __hex__(...) | x.__hex__() <==> hex(x) | | __int__(...) | x.__int__() <==> int(x) | | __invert__(...) | x.__invert__() <==> ~x | | __long__(...) | x.__long__() <==> long(x) | | __lshift__(...) | x.__lshift__(y) <==> x<<y | | __mod__(...) | x.__mod__(y) <==> x%y | | __mul__(...) | x.__mul__(y) <==> x*y | | __neg__(...) | x.__neg__() <==> -x | | __nonzero__(...) | x.__nonzero__() <==> x != 0 | | __oct__(...) | x.__oct__() <==> oct(x) | | __or__(...) | x.__or__(y) <==> x|y | | __pos__(...) | x.__pos__() <==> +x | | __pow__(...) | x.__pow__(y[, z]) <==> pow(x, y[, z]) | | __radd__(...) | x.__radd__(y) <==> y+x | | __rand__(...) | x.__rand__(y) <==> y&x | | __rdiv__(...) | x.__rdiv__(y) <==> y/x | | __rdivmod__(...) | x.__rdivmod__(y) <==> divmod(y, x) | | __reduce__(...) | | __repr__(...) | x.__repr__() <==> repr(x) | | __rfloordiv__(...) | x.__rfloordiv__(y) <==> y//x | | __rlshift__(...) | x.__rlshift__(y) <==> y<<x | | __rmod__(...) | x.__rmod__(y) <==> y%x | | __rmul__(...) | x.__rmul__(y) <==> y*x | | __ror__(...) | x.__ror__(y) <==> y|x | | __rpow__(...) | y.__rpow__(x[, z]) <==> pow(x, y[, z]) | | __rrshift__(...) | x.__rrshift__(y) <==> y>>x | | __rshift__(...) | x.__rshift__(y) <==> x>>y | | __rsub__(...) | x.__rsub__(y) <==> y-x | | __rtruediv__(...) | x.__rtruediv__(y) <==> y/x | | __rxor__(...) | x.__rxor__(y) <==> y^x | | __setstate__(...) | | __sizeof__(...) | | __str__(...) | x.__str__() <==> str(x) | | __sub__(...) | x.__sub__(y) <==> x-y | | __truediv__(...) | x.__truediv__(y) <==> x/y | | __xor__(...) | x.__xor__(y) <==> x^y | | all(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | getfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | setfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | base | base object | | data | pointer to start of data | | dtype | get array data-descriptor | | flags | integer value of flags | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension class ufunc(__builtin__.object) | Functions that operate element by element on whole arrays. | | To see the documentation for a specific ufunc, use np.info(). For | example, np.info(np.sin). Because ufuncs are written in C | (for speed) and linked into Python with NumPy's ufunc facility, | Python's help() function finds this page whenever help() is called | on a ufunc. | | A detailed explanation of ufuncs can be found in the "ufuncs.rst" | file in the NumPy reference guide. | | Unary ufuncs: | ============= | | op(X, out=None) | Apply op to X elementwise | | Parameters | ---------- | X : array_like | Input array. | out : array_like | An array to store the output. Must be the same shape as `X`. | | Returns | ------- | r : array_like | `r` will have the same shape as `X`; if out is provided, `r` | will be equal to out. | | Binary ufuncs: | ============== | | op(X, Y, out=None) | Apply `op` to `X` and `Y` elementwise. May "broadcast" to make | the shapes of `X` and `Y` congruent. | | The broadcasting rules are: | | * Dimensions of length 1 may be prepended to either array. | * Arrays may be repeated along dimensions of length 1. | | Parameters | ---------- | X : array_like | First input array. | Y : array_like | Second input array. | out : array_like | An array to store the output. Must be the same shape as the | output would have. | | Returns | ------- | r : array_like | The return value; if out is provided, `r` will be equal to out. | | Methods defined here: | | __call__(...) | x.__call__(...) <==> x(...) | | __repr__(...) | x.__repr__() <==> repr(x) | | __str__(...) | x.__str__() <==> str(x) | | accumulate(...) | accumulate(array, axis=0, dtype=None, out=None) | | Accumulate the result of applying the operator to all elements. | | For a one-dimensional array, accumulate produces results equivalent to:: | | r = np.empty(len(A)) | t = op.identity # op = the ufunc being applied to A's elements | for i in range(len(A)): | t = op(t, A[i]) | r[i] = t | return r | | For example, add.accumulate() is equivalent to np.cumsum(). | | For a multi-dimensional array, accumulate is applied along only one | axis (axis zero by default; see Examples below) so repeated use is | necessary if one wants to accumulate over multiple axes. | | Parameters | ---------- | array : array_like | The array to act on. | axis : int, optional | The axis along which to apply the accumulation; default is zero. | dtype : data-type code, optional | The data-type used to represent the intermediate results. Defaults | to the data-type of the output array if such is provided, or the | the data-type of the input array if no output array is provided. | out : ndarray, optional | A location into which the result is stored. If not provided a | freshly-allocated array is returned. | | Returns | ------- | r : ndarray | The accumulated values. If `out` was supplied, `r` is a reference to | `out`. | | Examples | -------- | 1-D array examples: | | >>> np.add.accumulate([2, 3, 5]) | array([ 2, 5, 10]) | >>> np.multiply.accumulate([2, 3, 5]) | array([ 2, 6, 30]) | | 2-D array examples: | | >>> I = np.eye(2) | >>> I | array([[ 1., 0.], | [ 0., 1.]]) | | Accumulate along axis 0 (rows), down columns: | | >>> np.add.accumulate(I, 0) | array([[ 1., 0.], | [ 1., 1.]]) | >>> np.add.accumulate(I) # no axis specified = axis zero | array([[ 1., 0.], | [ 1., 1.]]) | | Accumulate along axis 1 (columns), through rows: | | >>> np.add.accumulate(I, 1) | array([[ 1., 1.], | [ 0., 1.]]) | | at(...) | at(a, indices, b=None) | | Performs unbuffered in place operation on operand 'a' for elements | specified by 'indices'. For addition ufunc, this method is equivalent to | `a[indices] += b`, except that results are accumulated for elements that | are indexed more than once. For example, `a[[0,0]] += 1` will only | increment the first element once because of buffering, whereas | `add.at(a, [0,0], 1)` will increment the first element twice. | | .. versionadded:: 1.8.0 | | Parameters | ---------- | a : array_like | The array to perform in place operation on. | indices : array_like or tuple | Array like index object or slice object for indexing into first | operand. If first operand has multiple dimensions, indices can be a | tuple of array like index objects or slice objects. | b : array_like | Second operand for ufuncs requiring two operands. Operand must be | broadcastable over first operand after indexing or slicing. | | Examples | -------- | Set items 0 and 1 to their negative values: | | >>> a = np.array([1, 2, 3, 4]) | >>> np.negative.at(a, [0, 1]) | >>> print(a) | array([-1, -2, 3, 4]) | | :: | | Increment items 0 and 1, and increment item 2 twice: | | >>> a = np.array([1, 2, 3, 4]) | >>> np.add.at(a, [0, 1, 2, 2], 1) | >>> print(a) | array([2, 3, 5, 4]) | | :: | | Add items 0 and 1 in first array to second array, | and store results in first array: | | >>> a = np.array([1, 2, 3, 4]) | >>> b = np.array([1, 2]) | >>> np.add.at(a, [0, 1], b) | >>> print(a) | array([2, 4, 3, 4]) | | outer(...) | outer(A, B) | | Apply the ufunc `op` to all pairs (a, b) with a in `A` and b in `B`. | | Let ``M = A.ndim``, ``N = B.ndim``. Then the result, `C`, of | ``op.outer(A, B)`` is an array of dimension M + N such that: | | .. math:: C[i_0, ..., i_{M-1}, j_0, ..., j_{N-1}] = | op(A[i_0, ..., i_{M-1}], B[j_0, ..., j_{N-1}]) | | For `A` and `B` one-dimensional, this is equivalent to:: | | r = empty(len(A),len(B)) | for i in range(len(A)): | for j in range(len(B)): | r[i,j] = op(A[i], B[j]) # op = ufunc in question | | Parameters | ---------- | A : array_like | First array | B : array_like | Second array | | Returns | ------- | r : ndarray | Output array | | See Also | -------- | numpy.outer | | Examples | -------- | >>> np.multiply.outer([1, 2, 3], [4, 5, 6]) | array([[ 4, 5, 6], | [ 8, 10, 12], | [12, 15, 18]]) | | A multi-dimensional example: | | >>> A = np.array([[1, 2, 3], [4, 5, 6]]) | >>> A.shape | (2, 3) | >>> B = np.array([[1, 2, 3, 4]]) | >>> B.shape | (1, 4) | >>> C = np.multiply.outer(A, B) | >>> C.shape; C | (2, 3, 1, 4) | array([[[[ 1, 2, 3, 4]], | [[ 2, 4, 6, 8]], | [[ 3, 6, 9, 12]]], | [[[ 4, 8, 12, 16]], | [[ 5, 10, 15, 20]], | [[ 6, 12, 18, 24]]]]) | | reduce(...) | reduce(a, axis=0, dtype=None, out=None, keepdims=False) | | Reduces `a`'s dimension by one, by applying ufunc along one axis. | | Let :math:`a.shape = (N_0, ..., N_i, ..., N_{M-1})`. Then | :math:`ufunc.reduce(a, axis=i)[k_0, ..,k_{i-1}, k_{i+1}, .., k_{M-1}]` = | the result of iterating `j` over :math:`range(N_i)`, cumulatively applying | ufunc to each :math:`a[k_0, ..,k_{i-1}, j, k_{i+1}, .., k_{M-1}]`. | For a one-dimensional array, reduce produces results equivalent to: | :: | | r = op.identity # op = ufunc | for i in range(len(A)): | r = op(r, A[i]) | return r | | For example, add.reduce() is equivalent to sum(). | | Parameters | ---------- | a : array_like | The array to act on. | axis : None or int or tuple of ints, optional | Axis or axes along which a reduction is performed. | The default (`axis` = 0) is perform a reduction over the first | dimension of the input array. `axis` may be negative, in | which case it counts from the last to the first axis. | | .. versionadded:: 1.7.0 | | If this is `None`, a reduction is performed over all the axes. | If this is a tuple of ints, a reduction is performed on multiple | axes, instead of a single axis or all the axes as before. | | For operations which are either not commutative or not associative, | doing a reduction over multiple axes is not well-defined. The | ufuncs do not currently raise an exception in this case, but will | likely do so in the future. | dtype : data-type code, optional | The type used to represent the intermediate results. Defaults | to the data-type of the output array if this is provided, or | the data-type of the input array if no output array is provided. | out : ndarray, optional | A location into which the result is stored. If not provided, a | freshly-allocated array is returned. | keepdims : bool, optional | If this is set to True, the axes which are reduced are left | in the result as dimensions with size one. With this option, | the result will broadcast correctly against the original `arr`. | | .. versionadded:: 1.7.0 | | Returns | ------- | r : ndarray | The reduced array. If `out` was supplied, `r` is a reference to it. | | Examples | -------- | >>> np.multiply.reduce([2,3,5]) | 30 | | A multi-dimensional array example: | | >>> X = np.arange(8).reshape((2,2,2)) | >>> X | array([[[0, 1], | [2, 3]], | [[4, 5], | [6, 7]]]) | >>> np.add.reduce(X, 0) | array([[ 4, 6], | [ 8, 10]]) | >>> np.add.reduce(X) # confirm: default axis value is 0 | array([[ 4, 6], | [ 8, 10]]) | >>> np.add.reduce(X, 1) | array([[ 2, 4], | [10, 12]]) | >>> np.add.reduce(X, 2) | array([[ 1, 5], | [ 9, 13]]) | | reduceat(...) | reduceat(a, indices, axis=0, dtype=None, out=None) | | Performs a (local) reduce with specified slices over a single axis. | | For i in ``range(len(indices))``, `reduceat` computes | ``ufunc.reduce(a[indices[i]:indices[i+1]])``, which becomes the i-th | generalized "row" parallel to `axis` in the final result (i.e., in a | 2-D array, for example, if `axis = 0`, it becomes the i-th row, but if | `axis = 1`, it becomes the i-th column). There are three exceptions to this: | | * when ``i = len(indices) - 1`` (so for the last index), | ``indices[i+1] = a.shape[axis]``. | * if ``indices[i] >= indices[i + 1]``, the i-th generalized "row" is | simply ``a[indices[i]]``. | * if ``indices[i] >= len(a)`` or ``indices[i] < 0``, an error is raised. | | The shape of the output depends on the size of `indices`, and may be | larger than `a` (this happens if ``len(indices) > a.shape[axis]``). | | Parameters | ---------- | a : array_like | The array to act on. | indices : array_like | Paired indices, comma separated (not colon), specifying slices to | reduce. | axis : int, optional | The axis along which to apply the reduceat. | dtype : data-type code, optional | The type used to represent the intermediate results. Defaults | to the data type of the output array if this is provided, or | the data type of the input array if no output array is provided. | out : ndarray, optional | A location into which the result is stored. If not provided a | freshly-allocated array is returned. | | Returns | ------- | r : ndarray | The reduced values. If `out` was supplied, `r` is a reference to | `out`. | | Notes | ----- | A descriptive example: | | If `a` is 1-D, the function `ufunc.accumulate(a)` is the same as | ``ufunc.reduceat(a, indices)[::2]`` where `indices` is | ``range(len(array) - 1)`` with a zero placed | in every other element: | ``indices = zeros(2 * len(a) - 1)``, ``indices[1::2] = range(1, len(a))``. | | Don't be fooled by this attribute's name: `reduceat(a)` is not | necessarily smaller than `a`. | | Examples | -------- | To take the running sum of four successive values: | | >>> np.add.reduceat(np.arange(8),[0,4, 1,5, 2,6, 3,7])[::2] | array([ 6, 10, 14, 18]) | | A 2-D example: | | >>> x = np.linspace(0, 15, 16).reshape(4,4) | >>> x | array([[ 0., 1., 2., 3.], | [ 4., 5., 6., 7.], | [ 8., 9., 10., 11.], | [ 12., 13., 14., 15.]]) | | :: | | # reduce such that the result has the following five rows: | # [row1 + row2 + row3] | # [row4] | # [row2] | # [row3] | # [row1 + row2 + row3 + row4] | | >>> np.add.reduceat(x, [0, 3, 1, 2, 0]) | array([[ 12., 15., 18., 21.], | [ 12., 13., 14., 15.], | [ 4., 5., 6., 7.], | [ 8., 9., 10., 11.], | [ 24., 28., 32., 36.]]) | | :: | | # reduce such that result has the following two columns: | # [col1 * col2 * col3, col4] | | >>> np.multiply.reduceat(x, [0, 3], 1) | array([[ 0., 3.], | [ 120., 7.], | [ 720., 11.], | [ 2184., 15.]]) | | ---------------------------------------------------------------------- | Data descriptors defined here: | | identity | The identity value. | | Data attribute containing the identity element for the ufunc, if it has one. | If it does not, the attribute value is None. | | Examples | -------- | >>> np.add.identity | 0 | >>> np.multiply.identity | 1 | >>> np.power.identity | 1 | >>> print np.exp.identity | None | | nargs | The number of arguments. | | Data attribute containing the number of arguments the ufunc takes, including | optional ones. | | Notes | ----- | Typically this value will be one more than what you might expect because all | ufuncs take the optional "out" argument. | | Examples | -------- | >>> np.add.nargs | 3 | >>> np.multiply.nargs | 3 | >>> np.power.nargs | 3 | >>> np.exp.nargs | 2 | | nin | The number of inputs. | | Data attribute containing the number of arguments the ufunc treats as input. | | Examples | -------- | >>> np.add.nin | 2 | >>> np.multiply.nin | 2 | >>> np.power.nin | 2 | >>> np.exp.nin | 1 | | nout | The number of outputs. | | Data attribute containing the number of arguments the ufunc treats as output. | | Notes | ----- | Since all ufuncs can take output arguments, this will always be (at least) 1. | | Examples | -------- | >>> np.add.nout | 1 | >>> np.multiply.nout | 1 | >>> np.power.nout | 1 | >>> np.exp.nout | 1 | | ntypes | The number of types. | | The number of numerical NumPy types - of which there are 18 total - on which | the ufunc can operate. | | See Also | -------- | numpy.ufunc.types | | Examples | -------- | >>> np.add.ntypes | 18 | >>> np.multiply.ntypes | 18 | >>> np.power.ntypes | 17 | >>> np.exp.ntypes | 7 | >>> np.remainder.ntypes | 14 | | signature | | types | Returns a list with types grouped input->output. | | Data attribute listing the data-type "Domain-Range" groupings the ufunc can | deliver. The data-types are given using the character codes. | | See Also | -------- | numpy.ufunc.ntypes | | Examples | -------- | >>> np.add.types | ['??->?', 'bb->b', 'BB->B', 'hh->h', 'HH->H', 'ii->i', 'II->I', 'll->l', | 'LL->L', 'qq->q', 'QQ->Q', 'ff->f', 'dd->d', 'gg->g', 'FF->F', 'DD->D', | 'GG->G', 'OO->O'] | | >>> np.multiply.types | ['??->?', 'bb->b', 'BB->B', 'hh->h', 'HH->H', 'ii->i', 'II->I', 'll->l', | 'LL->L', 'qq->q', 'QQ->Q', 'ff->f', 'dd->d', 'gg->g', 'FF->F', 'DD->D', | 'GG->G', 'OO->O'] | | >>> np.power.types | ['bb->b', 'BB->B', 'hh->h', 'HH->H', 'ii->i', 'II->I', 'll->l', 'LL->L', | 'qq->q', 'QQ->Q', 'ff->f', 'dd->d', 'gg->g', 'FF->F', 'DD->D', 'GG->G', | 'OO->O'] | | >>> np.exp.types | ['f->f', 'd->d', 'g->g', 'F->F', 'D->D', 'G->G', 'O->O'] | | >>> np.remainder.types | ['bb->b', 'BB->B', 'hh->h', 'HH->H', 'ii->i', 'II->I', 'll->l', 'LL->L', | 'qq->q', 'QQ->Q', 'ff->f', 'dd->d', 'gg->g', 'OO->O'] uint = class uint32(unsignedinteger) | Method resolution order: | uint32 | unsignedinteger | integer | number | generic | __builtin__.object | | Methods defined here: | | __eq__(...) | x.__eq__(y) <==> x==y | | __ge__(...) | x.__ge__(y) <==> x>=y | | __gt__(...) | x.__gt__(y) <==> x>y | | __hash__(...) | x.__hash__() <==> hash(x) | | __index__(...) | x[y:z] <==> x[y.__index__():z.__index__()] | | __le__(...) | x.__le__(y) <==> x<=y | | __lt__(...) | x.__lt__(y) <==> x<y | | __ne__(...) | x.__ne__(y) <==> x!=y | | ---------------------------------------------------------------------- | Data and other attributes defined here: | | __new__ = <built-in method __new__ of type object> | T.__new__(S, ...) -> a new object with type S, a subtype of T | | ---------------------------------------------------------------------- | Data descriptors inherited from integer: | | denominator | denominator of value (1) | | numerator | numerator of value (the value itself) | | ---------------------------------------------------------------------- | Methods inherited from generic: | | __abs__(...) | x.__abs__() <==> abs(x) | | __add__(...) | x.__add__(y) <==> x+y | | __and__(...) | x.__and__(y) <==> x&y | | __array__(...) | sc.__array__(|type) return 0-dim array | | __array_wrap__(...) | sc.__array_wrap__(obj) return scalar from array | | __copy__(...) | | __deepcopy__(...) | | __div__(...) | x.__div__(y) <==> x/y | | __divmod__(...) | x.__divmod__(y) <==> divmod(x, y) | | __float__(...) | x.__float__() <==> float(x) | | __floordiv__(...) | x.__floordiv__(y) <==> x//y | | __format__(...) | NumPy array scalar formatter | | __getitem__(...) | x.__getitem__(y) <==> x[y] | | __hex__(...) | x.__hex__() <==> hex(x) | | __int__(...) | x.__int__() <==> int(x) | | __invert__(...) | x.__invert__() <==> ~x | | __long__(...) | x.__long__() <==> long(x) | | __lshift__(...) | x.__lshift__(y) <==> x<<y | | __mod__(...) | x.__mod__(y) <==> x%y | | __mul__(...) | x.__mul__(y) <==> x*y | | __neg__(...) | x.__neg__() <==> -x | | __nonzero__(...) | x.__nonzero__() <==> x != 0 | | __oct__(...) | x.__oct__() <==> oct(x) | | __or__(...) | x.__or__(y) <==> x|y | | __pos__(...) | x.__pos__() <==> +x | | __pow__(...) | x.__pow__(y[, z]) <==> pow(x, y[, z]) | | __radd__(...) | x.__radd__(y) <==> y+x | | __rand__(...) | x.__rand__(y) <==> y&x | | __rdiv__(...) | x.__rdiv__(y) <==> y/x | | __rdivmod__(...) | x.__rdivmod__(y) <==> divmod(y, x) | | __reduce__(...) | | __repr__(...) | x.__repr__() <==> repr(x) | | __rfloordiv__(...) | x.__rfloordiv__(y) <==> y//x | | __rlshift__(...) | x.__rlshift__(y) <==> y<<x | | __rmod__(...) | x.__rmod__(y) <==> y%x | | __rmul__(...) | x.__rmul__(y) <==> y*x | | __ror__(...) | x.__ror__(y) <==> y|x | | __rpow__(...) | y.__rpow__(x[, z]) <==> pow(x, y[, z]) | | __rrshift__(...) | x.__rrshift__(y) <==> y>>x | | __rshift__(...) | x.__rshift__(y) <==> x>>y | | __rsub__(...) | x.__rsub__(y) <==> y-x | | __rtruediv__(...) | x.__rtruediv__(y) <==> y/x | | __rxor__(...) | x.__rxor__(y) <==> y^x | | __setstate__(...) | | __sizeof__(...) | | __str__(...) | x.__str__() <==> str(x) | | __sub__(...) | x.__sub__(y) <==> x-y | | __truediv__(...) | x.__truediv__(y) <==> x/y | | __xor__(...) | x.__xor__(y) <==> x^y | | all(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | getfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | setfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | base | base object | | data | pointer to start of data | | dtype | get array data-descriptor | | flags | integer value of flags | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension uint0 = class uint64(unsignedinteger) | Method resolution order: | uint64 | unsignedinteger | integer | number | generic | __builtin__.object | | Methods defined here: | | __eq__(...) | x.__eq__(y) <==> x==y | | __ge__(...) | x.__ge__(y) <==> x>=y | | __gt__(...) | x.__gt__(y) <==> x>y | | __hash__(...) | x.__hash__() <==> hash(x) | | __index__(...) | x[y:z] <==> x[y.__index__():z.__index__()] | | __le__(...) | x.__le__(y) <==> x<=y | | __lt__(...) | x.__lt__(y) <==> x<y | | __ne__(...) | x.__ne__(y) <==> x!=y | | ---------------------------------------------------------------------- | Data and other attributes defined here: | | __new__ = <built-in method __new__ of type object> | T.__new__(S, ...) -> a new object with type S, a subtype of T | | ---------------------------------------------------------------------- | Data descriptors inherited from integer: | | denominator | denominator of value (1) | | numerator | numerator of value (the value itself) | | ---------------------------------------------------------------------- | Methods inherited from generic: | | __abs__(...) | x.__abs__() <==> abs(x) | | __add__(...) | x.__add__(y) <==> x+y | | __and__(...) | x.__and__(y) <==> x&y | | __array__(...) | sc.__array__(|type) return 0-dim array | | __array_wrap__(...) | sc.__array_wrap__(obj) return scalar from array | | __copy__(...) | | __deepcopy__(...) | | __div__(...) | x.__div__(y) <==> x/y | | __divmod__(...) | x.__divmod__(y) <==> divmod(x, y) | | __float__(...) | x.__float__() <==> float(x) | | __floordiv__(...) | x.__floordiv__(y) <==> x//y | | __format__(...) | NumPy array scalar formatter | | __getitem__(...) | x.__getitem__(y) <==> x[y] | | __hex__(...) | x.__hex__() <==> hex(x) | | __int__(...) | x.__int__() <==> int(x) | | __invert__(...) | x.__invert__() <==> ~x | | __long__(...) | x.__long__() <==> long(x) | | __lshift__(...) | x.__lshift__(y) <==> x<<y | | __mod__(...) | x.__mod__(y) <==> x%y | | __mul__(...) | x.__mul__(y) <==> x*y | | __neg__(...) | x.__neg__() <==> -x | | __nonzero__(...) | x.__nonzero__() <==> x != 0 | | __oct__(...) | x.__oct__() <==> oct(x) | | __or__(...) | x.__or__(y) <==> x|y | | __pos__(...) | x.__pos__() <==> +x | | __pow__(...) | x.__pow__(y[, z]) <==> pow(x, y[, z]) | | __radd__(...) | x.__radd__(y) <==> y+x | | __rand__(...) | x.__rand__(y) <==> y&x | | __rdiv__(...) | x.__rdiv__(y) <==> y/x | | __rdivmod__(...) | x.__rdivmod__(y) <==> divmod(y, x) | | __reduce__(...) | | __repr__(...) | x.__repr__() <==> repr(x) | | __rfloordiv__(...) | x.__rfloordiv__(y) <==> y//x | | __rlshift__(...) | x.__rlshift__(y) <==> y<<x | | __rmod__(...) | x.__rmod__(y) <==> y%x | | __rmul__(...) | x.__rmul__(y) <==> y*x | | __ror__(...) | x.__ror__(y) <==> y|x | | __rpow__(...) | y.__rpow__(x[, z]) <==> pow(x, y[, z]) | | __rrshift__(...) | x.__rrshift__(y) <==> y>>x | | __rshift__(...) | x.__rshift__(y) <==> x>>y | | __rsub__(...) | x.__rsub__(y) <==> y-x | | __rtruediv__(...) | x.__rtruediv__(y) <==> y/x | | __rxor__(...) | x.__rxor__(y) <==> y^x | | __setstate__(...) | | __sizeof__(...) | | __str__(...) | x.__str__() <==> str(x) | | __sub__(...) | x.__sub__(y) <==> x-y | | __truediv__(...) | x.__truediv__(y) <==> x/y | | __xor__(...) | x.__xor__(y) <==> x^y | | all(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | getfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | setfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | base | base object | | data | pointer to start of data | | dtype | get array data-descriptor | | flags | integer value of flags | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension class uint16(unsignedinteger) | Method resolution order: | uint16 | unsignedinteger | integer | number | generic | __builtin__.object | | Methods defined here: | | __eq__(...) | x.__eq__(y) <==> x==y | | __ge__(...) | x.__ge__(y) <==> x>=y | | __gt__(...) | x.__gt__(y) <==> x>y | | __hash__(...) | x.__hash__() <==> hash(x) | | __index__(...) | x[y:z] <==> x[y.__index__():z.__index__()] | | __le__(...) | x.__le__(y) <==> x<=y | | __lt__(...) | x.__lt__(y) <==> x<y | | __ne__(...) | x.__ne__(y) <==> x!=y | | ---------------------------------------------------------------------- | Data and other attributes defined here: | | __new__ = <built-in method __new__ of type object> | T.__new__(S, ...) -> a new object with type S, a subtype of T | | ---------------------------------------------------------------------- | Data descriptors inherited from integer: | | denominator | denominator of value (1) | | numerator | numerator of value (the value itself) | | ---------------------------------------------------------------------- | Methods inherited from generic: | | __abs__(...) | x.__abs__() <==> abs(x) | | __add__(...) | x.__add__(y) <==> x+y | | __and__(...) | x.__and__(y) <==> x&y | | __array__(...) | sc.__array__(|type) return 0-dim array | | __array_wrap__(...) | sc.__array_wrap__(obj) return scalar from array | | __copy__(...) | | __deepcopy__(...) | | __div__(...) | x.__div__(y) <==> x/y | | __divmod__(...) | x.__divmod__(y) <==> divmod(x, y) | | __float__(...) | x.__float__() <==> float(x) | | __floordiv__(...) | x.__floordiv__(y) <==> x//y | | __format__(...) | NumPy array scalar formatter | | __getitem__(...) | x.__getitem__(y) <==> x[y] | | __hex__(...) | x.__hex__() <==> hex(x) | | __int__(...) | x.__int__() <==> int(x) | | __invert__(...) | x.__invert__() <==> ~x | | __long__(...) | x.__long__() <==> long(x) | | __lshift__(...) | x.__lshift__(y) <==> x<<y | | __mod__(...) | x.__mod__(y) <==> x%y | | __mul__(...) | x.__mul__(y) <==> x*y | | __neg__(...) | x.__neg__() <==> -x | | __nonzero__(...) | x.__nonzero__() <==> x != 0 | | __oct__(...) | x.__oct__() <==> oct(x) | | __or__(...) | x.__or__(y) <==> x|y | | __pos__(...) | x.__pos__() <==> +x | | __pow__(...) | x.__pow__(y[, z]) <==> pow(x, y[, z]) | | __radd__(...) | x.__radd__(y) <==> y+x | | __rand__(...) | x.__rand__(y) <==> y&x | | __rdiv__(...) | x.__rdiv__(y) <==> y/x | | __rdivmod__(...) | x.__rdivmod__(y) <==> divmod(y, x) | | __reduce__(...) | | __repr__(...) | x.__repr__() <==> repr(x) | | __rfloordiv__(...) | x.__rfloordiv__(y) <==> y//x | | __rlshift__(...) | x.__rlshift__(y) <==> y<<x | | __rmod__(...) | x.__rmod__(y) <==> y%x | | __rmul__(...) | x.__rmul__(y) <==> y*x | | __ror__(...) | x.__ror__(y) <==> y|x | | __rpow__(...) | y.__rpow__(x[, z]) <==> pow(x, y[, z]) | | __rrshift__(...) | x.__rrshift__(y) <==> y>>x | | __rshift__(...) | x.__rshift__(y) <==> x>>y | | __rsub__(...) | x.__rsub__(y) <==> y-x | | __rtruediv__(...) | x.__rtruediv__(y) <==> y/x | | __rxor__(...) | x.__rxor__(y) <==> y^x | | __setstate__(...) | | __sizeof__(...) | | __str__(...) | x.__str__() <==> str(x) | | __sub__(...) | x.__sub__(y) <==> x-y | | __truediv__(...) | x.__truediv__(y) <==> x/y | | __xor__(...) | x.__xor__(y) <==> x^y | | all(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | getfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | setfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | base | base object | | data | pointer to start of data | | dtype | get array data-descriptor | | flags | integer value of flags | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension class uint32(unsignedinteger) | Method resolution order: | uint32 | unsignedinteger | integer | number | generic | __builtin__.object | | Methods defined here: | | __eq__(...) | x.__eq__(y) <==> x==y | | __ge__(...) | x.__ge__(y) <==> x>=y | | __gt__(...) | x.__gt__(y) <==> x>y | | __hash__(...) | x.__hash__() <==> hash(x) | | __index__(...) | x[y:z] <==> x[y.__index__():z.__index__()] | | __le__(...) | x.__le__(y) <==> x<=y | | __lt__(...) | x.__lt__(y) <==> x<y | | __ne__(...) | x.__ne__(y) <==> x!=y | | ---------------------------------------------------------------------- | Data and other attributes defined here: | | __new__ = <built-in method __new__ of type object> | T.__new__(S, ...) -> a new object with type S, a subtype of T | | ---------------------------------------------------------------------- | Data descriptors inherited from integer: | | denominator | denominator of value (1) | | numerator | numerator of value (the value itself) | | ---------------------------------------------------------------------- | Methods inherited from generic: | | __abs__(...) | x.__abs__() <==> abs(x) | | __add__(...) | x.__add__(y) <==> x+y | | __and__(...) | x.__and__(y) <==> x&y | | __array__(...) | sc.__array__(|type) return 0-dim array | | __array_wrap__(...) | sc.__array_wrap__(obj) return scalar from array | | __copy__(...) | | __deepcopy__(...) | | __div__(...) | x.__div__(y) <==> x/y | | __divmod__(...) | x.__divmod__(y) <==> divmod(x, y) | | __float__(...) | x.__float__() <==> float(x) | | __floordiv__(...) | x.__floordiv__(y) <==> x//y | | __format__(...) | NumPy array scalar formatter | | __getitem__(...) | x.__getitem__(y) <==> x[y] | | __hex__(...) | x.__hex__() <==> hex(x) | | __int__(...) | x.__int__() <==> int(x) | | __invert__(...) | x.__invert__() <==> ~x | | __long__(...) | x.__long__() <==> long(x) | | __lshift__(...) | x.__lshift__(y) <==> x<<y | | __mod__(...) | x.__mod__(y) <==> x%y | | __mul__(...) | x.__mul__(y) <==> x*y | | __neg__(...) | x.__neg__() <==> -x | | __nonzero__(...) | x.__nonzero__() <==> x != 0 | | __oct__(...) | x.__oct__() <==> oct(x) | | __or__(...) | x.__or__(y) <==> x|y | | __pos__(...) | x.__pos__() <==> +x | | __pow__(...) | x.__pow__(y[, z]) <==> pow(x, y[, z]) | | __radd__(...) | x.__radd__(y) <==> y+x | | __rand__(...) | x.__rand__(y) <==> y&x | | __rdiv__(...) | x.__rdiv__(y) <==> y/x | | __rdivmod__(...) | x.__rdivmod__(y) <==> divmod(y, x) | | __reduce__(...) | | __repr__(...) | x.__repr__() <==> repr(x) | | __rfloordiv__(...) | x.__rfloordiv__(y) <==> y//x | | __rlshift__(...) | x.__rlshift__(y) <==> y<<x | | __rmod__(...) | x.__rmod__(y) <==> y%x | | __rmul__(...) | x.__rmul__(y) <==> y*x | | __ror__(...) | x.__ror__(y) <==> y|x | | __rpow__(...) | y.__rpow__(x[, z]) <==> pow(x, y[, z]) | | __rrshift__(...) | x.__rrshift__(y) <==> y>>x | | __rshift__(...) | x.__rshift__(y) <==> x>>y | | __rsub__(...) | x.__rsub__(y) <==> y-x | | __rtruediv__(...) | x.__rtruediv__(y) <==> y/x | | __rxor__(...) | x.__rxor__(y) <==> y^x | | __setstate__(...) | | __sizeof__(...) | | __str__(...) | x.__str__() <==> str(x) | | __sub__(...) | x.__sub__(y) <==> x-y | | __truediv__(...) | x.__truediv__(y) <==> x/y | | __xor__(...) | x.__xor__(y) <==> x^y | | all(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | getfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | setfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | base | base object | | data | pointer to start of data | | dtype | get array data-descriptor | | flags | integer value of flags | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension class uint64(unsignedinteger) | Method resolution order: | uint64 | unsignedinteger | integer | number | generic | __builtin__.object | | Methods defined here: | | __eq__(...) | x.__eq__(y) <==> x==y | | __ge__(...) | x.__ge__(y) <==> x>=y | | __gt__(...) | x.__gt__(y) <==> x>y | | __hash__(...) | x.__hash__() <==> hash(x) | | __index__(...) | x[y:z] <==> x[y.__index__():z.__index__()] | | __le__(...) | x.__le__(y) <==> x<=y | | __lt__(...) | x.__lt__(y) <==> x<y | | __ne__(...) | x.__ne__(y) <==> x!=y | | ---------------------------------------------------------------------- | Data and other attributes defined here: | | __new__ = <built-in method __new__ of type object> | T.__new__(S, ...) -> a new object with type S, a subtype of T | | ---------------------------------------------------------------------- | Data descriptors inherited from integer: | | denominator | denominator of value (1) | | numerator | numerator of value (the value itself) | | ---------------------------------------------------------------------- | Methods inherited from generic: | | __abs__(...) | x.__abs__() <==> abs(x) | | __add__(...) | x.__add__(y) <==> x+y | | __and__(...) | x.__and__(y) <==> x&y | | __array__(...) | sc.__array__(|type) return 0-dim array | | __array_wrap__(...) | sc.__array_wrap__(obj) return scalar from array | | __copy__(...) | | __deepcopy__(...) | | __div__(...) | x.__div__(y) <==> x/y | | __divmod__(...) | x.__divmod__(y) <==> divmod(x, y) | | __float__(...) | x.__float__() <==> float(x) | | __floordiv__(...) | x.__floordiv__(y) <==> x//y | | __format__(...) | NumPy array scalar formatter | | __getitem__(...) | x.__getitem__(y) <==> x[y] | | __hex__(...) | x.__hex__() <==> hex(x) | | __int__(...) | x.__int__() <==> int(x) | | __invert__(...) | x.__invert__() <==> ~x | | __long__(...) | x.__long__() <==> long(x) | | __lshift__(...) | x.__lshift__(y) <==> x<<y | | __mod__(...) | x.__mod__(y) <==> x%y | | __mul__(...) | x.__mul__(y) <==> x*y | | __neg__(...) | x.__neg__() <==> -x | | __nonzero__(...) | x.__nonzero__() <==> x != 0 | | __oct__(...) | x.__oct__() <==> oct(x) | | __or__(...) | x.__or__(y) <==> x|y | | __pos__(...) | x.__pos__() <==> +x | | __pow__(...) | x.__pow__(y[, z]) <==> pow(x, y[, z]) | | __radd__(...) | x.__radd__(y) <==> y+x | | __rand__(...) | x.__rand__(y) <==> y&x | | __rdiv__(...) | x.__rdiv__(y) <==> y/x | | __rdivmod__(...) | x.__rdivmod__(y) <==> divmod(y, x) | | __reduce__(...) | | __repr__(...) | x.__repr__() <==> repr(x) | | __rfloordiv__(...) | x.__rfloordiv__(y) <==> y//x | | __rlshift__(...) | x.__rlshift__(y) <==> y<<x | | __rmod__(...) | x.__rmod__(y) <==> y%x | | __rmul__(...) | x.__rmul__(y) <==> y*x | | __ror__(...) | x.__ror__(y) <==> y|x | | __rpow__(...) | y.__rpow__(x[, z]) <==> pow(x, y[, z]) | | __rrshift__(...) | x.__rrshift__(y) <==> y>>x | | __rshift__(...) | x.__rshift__(y) <==> x>>y | | __rsub__(...) | x.__rsub__(y) <==> y-x | | __rtruediv__(...) | x.__rtruediv__(y) <==> y/x | | __rxor__(...) | x.__rxor__(y) <==> y^x | | __setstate__(...) | | __sizeof__(...) | | __str__(...) | x.__str__() <==> str(x) | | __sub__(...) | x.__sub__(y) <==> x-y | | __truediv__(...) | x.__truediv__(y) <==> x/y | | __xor__(...) | x.__xor__(y) <==> x^y | | all(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | getfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | setfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | base | base object | | data | pointer to start of data | | dtype | get array data-descriptor | | flags | integer value of flags | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension class uint8(unsignedinteger) | Method resolution order: | uint8 | unsignedinteger | integer | number | generic | __builtin__.object | | Methods defined here: | | __eq__(...) | x.__eq__(y) <==> x==y | | __ge__(...) | x.__ge__(y) <==> x>=y | | __gt__(...) | x.__gt__(y) <==> x>y | | __hash__(...) | x.__hash__() <==> hash(x) | | __index__(...) | x[y:z] <==> x[y.__index__():z.__index__()] | | __le__(...) | x.__le__(y) <==> x<=y | | __lt__(...) | x.__lt__(y) <==> x<y | | __ne__(...) | x.__ne__(y) <==> x!=y | | ---------------------------------------------------------------------- | Data and other attributes defined here: | | __new__ = <built-in method __new__ of type object> | T.__new__(S, ...) -> a new object with type S, a subtype of T | | ---------------------------------------------------------------------- | Data descriptors inherited from integer: | | denominator | denominator of value (1) | | numerator | numerator of value (the value itself) | | ---------------------------------------------------------------------- | Methods inherited from generic: | | __abs__(...) | x.__abs__() <==> abs(x) | | __add__(...) | x.__add__(y) <==> x+y | | __and__(...) | x.__and__(y) <==> x&y | | __array__(...) | sc.__array__(|type) return 0-dim array | | __array_wrap__(...) | sc.__array_wrap__(obj) return scalar from array | | __copy__(...) | | __deepcopy__(...) | | __div__(...) | x.__div__(y) <==> x/y | | __divmod__(...) | x.__divmod__(y) <==> divmod(x, y) | | __float__(...) | x.__float__() <==> float(x) | | __floordiv__(...) | x.__floordiv__(y) <==> x//y | | __format__(...) | NumPy array scalar formatter | | __getitem__(...) | x.__getitem__(y) <==> x[y] | | __hex__(...) | x.__hex__() <==> hex(x) | | __int__(...) | x.__int__() <==> int(x) | | __invert__(...) | x.__invert__() <==> ~x | | __long__(...) | x.__long__() <==> long(x) | | __lshift__(...) | x.__lshift__(y) <==> x<<y | | __mod__(...) | x.__mod__(y) <==> x%y | | __mul__(...) | x.__mul__(y) <==> x*y | | __neg__(...) | x.__neg__() <==> -x | | __nonzero__(...) | x.__nonzero__() <==> x != 0 | | __oct__(...) | x.__oct__() <==> oct(x) | | __or__(...) | x.__or__(y) <==> x|y | | __pos__(...) | x.__pos__() <==> +x | | __pow__(...) | x.__pow__(y[, z]) <==> pow(x, y[, z]) | | __radd__(...) | x.__radd__(y) <==> y+x | | __rand__(...) | x.__rand__(y) <==> y&x | | __rdiv__(...) | x.__rdiv__(y) <==> y/x | | __rdivmod__(...) | x.__rdivmod__(y) <==> divmod(y, x) | | __reduce__(...) | | __repr__(...) | x.__repr__() <==> repr(x) | | __rfloordiv__(...) | x.__rfloordiv__(y) <==> y//x | | __rlshift__(...) | x.__rlshift__(y) <==> y<<x | | __rmod__(...) | x.__rmod__(y) <==> y%x | | __rmul__(...) | x.__rmul__(y) <==> y*x | | __ror__(...) | x.__ror__(y) <==> y|x | | __rpow__(...) | y.__rpow__(x[, z]) <==> pow(x, y[, z]) | | __rrshift__(...) | x.__rrshift__(y) <==> y>>x | | __rshift__(...) | x.__rshift__(y) <==> x>>y | | __rsub__(...) | x.__rsub__(y) <==> y-x | | __rtruediv__(...) | x.__rtruediv__(y) <==> y/x | | __rxor__(...) | x.__rxor__(y) <==> y^x | | __setstate__(...) | | __sizeof__(...) | | __str__(...) | x.__str__() <==> str(x) | | __sub__(...) | x.__sub__(y) <==> x-y | | __truediv__(...) | x.__truediv__(y) <==> x/y | | __xor__(...) | x.__xor__(y) <==> x^y | | all(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | getfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | setfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See Also | -------- | The corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | base | base object | | data | pointer to start of data | | dtype | get array data-descriptor | | flags | integer value of flags | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension
0 0
- NumPy doc (五)
- NumPy doc (一)
- NumPy doc (二)
- NumPy doc (三)
- NumPy doc(四)
- NumPy doc (六)
- NumPy doc (七)
- Numpy(五)
- NumPy教程之(五)
- Numpy 数组基本运算 (五)
- 机器学习笔记(五):numpy入门
- numpy 辨异 (五)—— numpy.ravel() vs numpy.flatten()
- numpy 辨异 (五)—— numpy.ravel() vs numpy.flatten()
- 利用Python数据分析:Numpy基础(五)
- 机器学习之numpy和matplotlib学习(五)
- numpy的学习笔记(五)
- elasticsearch 学习博客系列<五> ES 中 index-doc 的 更新(java)
- 网络创业成功五要素.doc
- linux---sed,awk
- git常用操作
- JavaScript 面向对象编程(一)
- 链表
- POJ 1849. Two 树形DP解法 c++代码
- NumPy doc (五)
- Makefile选项CFLAGS,LDFLAGS,LIBS
- 使用了angular js IE9以下浏览器的适配问题。
- 线程wait小案例
- H5下自适应页面的meta 与 CSS
- 集成 PHP 应用和 Solr 搜索引擎
- HTTP Request header
- xilinx 配置芯片
- 【LeetCode】19. Remove Nth Node From End of List