uintc = 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
uintp = 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
ulonglong = 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
unicode0 = class unicode_(__builtin__.unicode, character)
| Method resolution order:
| unicode_
| __builtin__.unicode
| __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__.unicode:
|
| __add__(...)
| x.__add__(y) <==> x+y
|
| __contains__(...)
| x.__contains__(y) <==> y in x
|
| __format__(...)
| S.__format__(format_spec) -> unicode
|
| 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() -> unicode
|
| Return a capitalized version of S, i.e. make the first character
| have upper case and the rest lower case.
|
| center(...)
| S.center(width[, fillchar]) -> unicode
|
| Return S centered in a Unicode 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
| Unicode string S[start:end]. Optional arguments start and end are
| interpreted as in slice notation.
|
| decode(...)
| S.decode([encoding[,errors]]) -> string or unicode
|
| 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]]) -> string or unicode
|
| 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 can 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]) -> unicode
|
| 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) -> unicode
|
| 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.
|
| isdecimal(...)
| S.isdecimal() -> bool
|
| Return True if there are only decimal characters 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.
|
| isnumeric(...)
| S.isnumeric() -> bool
|
| Return True if there are only numeric characters 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. upper- and titlecase 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) -> unicode
|
| Return a string which is the concatenation of the strings in the
| iterable. The separator between elements is S.
|
| ljust(...)
| S.ljust(width[, fillchar]) -> int
|
| Return S left-justified in a Unicode string of length width. Padding is
| done using the specified fill character (default is a space).
|
| lower(...)
| S.lower() -> unicode
|
| Return a copy of the string S converted to lowercase.
|
| lstrip(...)
| S.lstrip([chars]) -> 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 a str, it 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]) -> unicode
|
| Return a copy of 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]) -> unicode
|
| Return S right-justified in a Unicode 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 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, any whitespace string
| is a separator.
|
| rstrip(...)
| S.rstrip([chars]) -> 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 a str, it will be converted to unicode before stripping
|
| split(...)
| S.split([sep [,maxsplit]]) -> list of strings
|
| Return a list of the words in 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]) -> 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 a str, it will be converted to unicode before stripping
|
| swapcase(...)
| S.swapcase() -> unicode
|
| Return a copy of S with uppercase characters converted to lowercase
| and vice versa.
|
| title(...)
| S.title() -> unicode
|
| Return a titlecased version of S, i.e. words start with title case
| characters, all remaining cased characters have lower case.
|
| translate(...)
| S.translate(table) -> unicode
|
| Return a copy of the string S, where all characters have been mapped
| through the given translation table, which must be a mapping of
| Unicode ordinals to Unicode ordinals, Unicode strings or None.
| Unmapped characters are left untouched. Characters mapped to None
| are deleted.
|
| upper(...)
| S.upper() -> unicode
|
| Return a copy of S converted to uppercase.
|
| zfill(...)
| S.zfill(width) -> unicode
|
| 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 unicode_(__builtin__.unicode, character)
| Method resolution order:
| unicode_
| __builtin__.unicode
| __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__.unicode:
|
| __add__(...)
| x.__add__(y) <==> x+y
|
| __contains__(...)
| x.__contains__(y) <==> y in x
|
| __format__(...)
| S.__format__(format_spec) -> unicode
|
| 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() -> unicode
|
| Return a capitalized version of S, i.e. make the first character
| have upper case and the rest lower case.
|
| center(...)
| S.center(width[, fillchar]) -> unicode
|
| Return S centered in a Unicode 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
| Unicode string S[start:end]. Optional arguments start and end are
| interpreted as in slice notation.
|
| decode(...)
| S.decode([encoding[,errors]]) -> string or unicode
|
| 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]]) -> string or unicode
|
| 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 can 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]) -> unicode
|
| 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) -> unicode
|
| 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.
|
| isdecimal(...)
| S.isdecimal() -> bool
|
| Return True if there are only decimal characters 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.
|
| isnumeric(...)
| S.isnumeric() -> bool
|
| Return True if there are only numeric characters 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. upper- and titlecase 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) -> unicode
|
| Return a string which is the concatenation of the strings in the
| iterable. The separator between elements is S.
|
| ljust(...)
| S.ljust(width[, fillchar]) -> int
|
| Return S left-justified in a Unicode string of length width. Padding is
| done using the specified fill character (default is a space).
|
| lower(...)
| S.lower() -> unicode
|
| Return a copy of the string S converted to lowercase.
|
| lstrip(...)
| S.lstrip([chars]) -> 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 a str, it 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]) -> unicode
|
| Return a copy of 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]) -> unicode
|
| Return S right-justified in a Unicode 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 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, any whitespace string
| is a separator.
|
| rstrip(...)
| S.rstrip([chars]) -> 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 a str, it will be converted to unicode before stripping
|
| split(...)
| S.split([sep [,maxsplit]]) -> list of strings
|
| Return a list of the words in 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]) -> 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 a str, it will be converted to unicode before stripping
|
| swapcase(...)
| S.swapcase() -> unicode
|
| Return a copy of S with uppercase characters converted to lowercase
| and vice versa.
|
| title(...)
| S.title() -> unicode
|
| Return a titlecased version of S, i.e. words start with title case
| characters, all remaining cased characters have lower case.
|
| translate(...)
| S.translate(table) -> unicode
|
| Return a copy of the string S, where all characters have been mapped
| through the given translation table, which must be a mapping of
| Unicode ordinals to Unicode ordinals, Unicode strings or None.
| Unmapped characters are left untouched. Characters mapped to None
| are deleted.
|
| upper(...)
| S.upper() -> unicode
|
| Return a copy of S converted to uppercase.
|
| zfill(...)
| S.zfill(width) -> unicode
|
| 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 unsignedinteger(integer)
| Method resolution order:
| unsignedinteger
| 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
ushort = 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 vectorize(__builtin__.object)
| vectorize(pyfunc, otypes='', doc=None, excluded=None, cache=False)
|
| Generalized function class.
|
| Define a vectorized function which takes a nested sequence
| of objects or numpy arrays as inputs and returns a
| numpy array as output. The vectorized function evaluates `pyfunc` over
| successive tuples of the input arrays like the python map function,
| except it uses the broadcasting rules of numpy.
|
| The data type of the output of `vectorized` is determined by calling
| the function with the first element of the input. This can be avoided
| by specifying the `otypes` argument.
|
| Parameters
| ----------
| pyfunc : callable
| A python function or method.
| otypes : str or list of dtypes, optional
| The output data type. It must be specified as either a string of
| typecode characters or a list of data type specifiers. There should
| be one data type specifier for each output.
| doc : str, optional
| The docstring for the function. If `None`, the docstring will be the
| ``pyfunc.__doc__``.
| excluded : set, optional
| Set of strings or integers representing the positional or keyword
| arguments for which the function will not be vectorized. These will be
| passed directly to `pyfunc` unmodified.
|
| .. versionadded:: 1.7.0
|
| cache : bool, optional
| If `True`, then cache the first function call that determines the number
| of outputs if `otypes` is not provided.
|
| .. versionadded:: 1.7.0
|
| Returns
| -------
| vectorized : callable
| Vectorized function.
|
| Examples
| --------
| >>> def myfunc(a, b):
| ... "Return a-b if a>b, otherwise return a+b"
| ... if a > b:
| ... return a - b
| ... else:
| ... return a + b
|
| >>> vfunc = np.vectorize(myfunc)
| >>> vfunc([1, 2, 3, 4], 2)
| array([3, 4, 1, 2])
|
| The docstring is taken from the input function to `vectorize` unless it
| is specified
|
| >>> vfunc.__doc__
| 'Return a-b if a>b, otherwise return a+b'
| >>> vfunc = np.vectorize(myfunc, doc='Vectorized `myfunc`')
| >>> vfunc.__doc__
| 'Vectorized `myfunc`'
|
| The output type is determined by evaluating the first element of the input,
| unless it is specified
|
| >>> out = vfunc([1, 2, 3, 4], 2)
| >>> type(out[0])
| <type 'numpy.int32'>
| >>> vfunc = np.vectorize(myfunc, otypes=[np.float])
| >>> out = vfunc([1, 2, 3, 4], 2)
| >>> type(out[0])
| <type 'numpy.float64'>
|
| The `excluded` argument can be used to prevent vectorizing over certain
| arguments. This can be useful for array-like arguments of a fixed length
| such as the coefficients for a polynomial as in `polyval`:
|
| >>> def mypolyval(p, x):
| ... _p = list(p)
| ... res = _p.pop(0)
| ... while _p:
| ... res = res*x + _p.pop(0)
| ... return res
| >>> vpolyval = np.vectorize(mypolyval, excluded=['p'])
| >>> vpolyval(p=[1, 2, 3], x=[0, 1])
| array([3, 6])
|
| Positional arguments may also be excluded by specifying their position:
|
| >>> vpolyval.excluded.add(0)
| >>> vpolyval([1, 2, 3], x=[0, 1])
| array([3, 6])
|
| Notes
| -----
| The `vectorize` function is provided primarily for convenience, not for
| performance. The implementation is essentially a for loop.
|
| If `otypes` is not specified, then a call to the function with the
| first argument will be used to determine the number of outputs. The
| results of this call will be cached if `cache` is `True` to prevent
| calling the function twice. However, to implement the cache, the
| original function must be wrapped which will slow down subsequent
| calls, so only do this if your function is expensive.
|
| The new keyword argument interface and `excluded` argument support
| further degrades performance.
|
| Methods defined here:
|
| __call__(self, *args, **kwargs)
| Return arrays with the results of `pyfunc` broadcast (vectorized) over
| `args` and `kwargs` not in `excluded`.
|
| __init__(self, pyfunc, otypes='', doc=None, excluded=None, cache=False)
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables (if defined)
|
| __weakref__
| list of weak references to the object (if defined)
class void(flexible)
| Method resolution order:
| void
| flexible
| generic
| __builtin__.object
|
| Methods defined here:
|
| __delitem__(...)
| x.__delitem__(y) <==> del x[y]
|
| __eq__(...)
| x.__eq__(y) <==> x==y
|
| __ge__(...)
| x.__ge__(y) <==> x>=y
|
| __getitem__(...)
| x.__getitem__(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 defined here:
|
| dtype
| dtype object
|
| flags
| integer value of flags
|
| ----------------------------------------------------------------------
| 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
|
| __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.
|
| 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
void0 = class void(flexible)
| Method resolution order:
| void
| flexible
| generic
| __builtin__.object
|
| Methods defined here:
|
| __delitem__(...)
| x.__delitem__(y) <==> del x[y]
|
| __eq__(...)
| x.__eq__(y) <==> x==y
|
| __ge__(...)
| x.__ge__(y) <==> x>=y
|
| __getitem__(...)
| x.__getitem__(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 defined here:
|
| dtype
| dtype object
|
| flags
| integer value of flags
|
| ----------------------------------------------------------------------
| 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
|
| __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.
|
| 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
FUNCTIONS
add_docstring(...)
add_docstring(obj, docstring)
Add a docstring to a built-in obj if possible.
If the obj already has a docstring raise a RuntimeError
If this routine does not know how to add a docstring to the object
raise a TypeError
add_newdoc(place, obj, doc)
Adds documentation to obj which is in module place.
If doc is a string add it to obj as a docstring
If doc is a tuple, then the first element is interpreted as
an attribute of obj and the second as the docstring
(method, docstring)
If doc is a list, then each element of the list should be a
sequence of length two --> [(method1, docstring1),
(method2, docstring2), ...]
This routine never raises an error.
This routine cannot modify read-only docstrings, as appear
in new-style classes or built-in functions. Because this
routine never raises an error the caller must check manually
that the docstrings were changed.
add_newdoc_ufunc = _add_newdoc_ufunc(...)
add_ufunc_docstring(ufunc, new_docstring)
Replace the docstring for a ufunc with new_docstring.
This method will only work if the current docstring for
the ufunc is NULL. (At the C level, i.e. when ufunc->doc is NULL.)
Parameters
----------
ufunc : numpy.ufunc
A ufunc whose current doc is NULL.
new_docstring : string
The new docstring for the ufunc.
Notes
-----
This method allocates memory for new_docstring on
the heap. Technically this creates a mempory leak, since this
memory will not be reclaimed until the end of the program
even if the ufunc itself is removed. However this will only
be a problem if the user is repeatedly creating ufuncs with
no documentation, adding documentation via add_newdoc_ufunc,
and then throwing away the ufunc.
alen(a)
Return the length of the first dimension of the input array.
Parameters
----------
a : array_like
Input array.
Returns
-------
alen : int
Length of the first dimension of `a`.
See Also
--------
shape, size
Examples
--------
a = np.zeros((7,4,5))
a.shape[0]
7
np.alen(a)
7
all(a, axis=None, out=None, keepdims=False)
Test whether all array elements along a given axis evaluate to True.
Parameters
----------
a : array_like
Input array or object that can be converted to an array.
axis : None or int or tuple of ints, optional
Axis or axes along which a logical AND reduction is performed.
The default (`axis` = `None`) is to perform a logical AND over all
the dimensions 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 a tuple of ints, a reduction is performed on multiple
axes, instead of a single axis or all the axes as before.
out : ndarray, optional
Alternate output array in which to place the result.
It must have the same shape as the expected output and its
type is preserved (e.g., if ``dtype(out)`` is float, the result
will consist of 0.0's and 1.0's). See `doc.ufuncs` (Section
"Output arguments") for more details.
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`.
Returns
-------
all : ndarray, bool
A new boolean or array is returned unless `out` is specified,
in which case a reference to `out` is returned.
See Also
--------
ndarray.all : equivalent method
any : Test whether any element along a given axis evaluates to True.
Notes
-----
Not a Number (NaN), positive infinity and negative infinity
evaluate to `True` because these are not equal to zero.
Examples
--------
np.all([[True,False],[True,True]])
False
np.all([[True,False],[True,True]], axis=0)
array([ True, False], dtype=bool)
np.all([-1, 4, 5])
True
np.all([1.0, np.nan])
True
o=np.array([False])
z=np.all([-1, 4, 5], out=o)
id(z), id(o), z # doctest: +SKIP
(28293632, 28293632, array([ True], dtype=bool))
allclose(a, b, rtol=1e-05, atol=1e-08, equal_nan=False)
Returns True if two arrays are element-wise equal within a tolerance.
The tolerance values are positive, typically very small numbers. The
relative difference (`rtol` * abs(`b`)) and the absolute difference
`atol` are added together to compare against the absolute difference
between `a` and `b`.
If either array contains one or more NaNs, False is returned.
Infs are treated as equal if they are in the same place and of the same
sign in both arrays.
Parameters
----------
a, b : array_like
Input arrays to compare.
rtol : float
The relative tolerance parameter (see Notes).
atol : float
The absolute tolerance parameter (see Notes).
equal_nan : bool
Whether to compare NaN's as equal. If True, NaN's in `a` will be
considered equal to NaN's in `b` in the output array.
.. versionadded:: 1.10.0
Returns
-------
allclose : bool
Returns True if the two arrays are equal within the given
tolerance; False otherwise.
See Also
--------
isclose, all, any
Notes
-----
If the following equation is element-wise True, then allclose returns
True.
absolute(`a` - `b`) <= (`atol` + `rtol` * absolute(`b`))
The above equation is not symmetric in `a` and `b`, so that
`allclose(a, b)` might be different from `allclose(b, a)` in
some rare cases.
Examples
--------
np.allclose([1e10,1e-7], [1.00001e10,1e-8])
False
np.allclose([1e10,1e-8], [1.00001e10,1e-9])
True
np.allclose([1e10,1e-8], [1.0001e10,1e-9])
False
np.allclose([1.0, np.nan], [1.0, np.nan])
False
np.allclose([1.0, np.nan], [1.0, np.nan], equal_nan=True)
True
alltrue(a, axis=None, out=None, keepdims=False)
Check if all elements of input array are true.
See Also
--------
numpy.all : Equivalent function; see for details.
alterdot()
Change `dot`, `vdot`, and `inner` to use accelerated BLAS functions.
Typically, as a user of Numpy, you do not explicitly call this
function. If Numpy is built with an accelerated BLAS, this function is
automatically called when Numpy is imported.
When Numpy is built with an accelerated BLAS like ATLAS, these
functions are replaced to make use of the faster implementations. The
faster implementations only affect float32, float64, complex64, and
complex128 arrays. Furthermore, the BLAS API only includes
matrix-matrix, matrix-vector, and vector-vector products. Products of
arrays with larger dimensionalities use the built in functions and are
not accelerated.
.. note:: Deprecated in Numpy 1.10
The cblas functions have been integrated into the multarray
module and alterdot now longer does anything. It will be
removed in Numpy 1.11.0.
See Also
--------
restoredot : `restoredot` undoes the effects of `alterdot`.
amax(a, axis=None, out=None, keepdims=False)
Return the maximum of an array or maximum along an axis.
Parameters
----------
a : array_like
Input data.
axis : None or int or tuple of ints, optional
Axis or axes along which to operate. By default, flattened input is
used.
.. versionadded: 1.7.0
If this is a tuple of ints, the maximum is selected over multiple axes,
instead of a single axis or all the axes as before.
out : ndarray, optional
Alternative output array in which to place the result. Must
be of the same shape and buffer length as the expected output.
See `doc.ufuncs` (Section "Output arguments") for more details.
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`.
Returns
-------
amax : ndarray or scalar
Maximum of `a`. If `axis` is None, the result is a scalar value.
If `axis` is given, the result is an array of dimension
``a.ndim - 1``.
See Also
--------
amin :
The minimum value of an array along a given axis, propagating any NaNs.
nanmax :
The maximum value of an array along a given axis, ignoring any NaNs.
maximum :
Element-wise maximum of two arrays, propagating any NaNs.
fmax :
Element-wise maximum of two arrays, ignoring any NaNs.
argmax :
Return the indices of the maximum values.
nanmin, minimum, fmin
Notes
-----
NaN values are propagated, that is if at least one item is NaN, the
corresponding max value will be NaN as well. To ignore NaN values
(MATLAB behavior), please use nanmax.
Don't use `amax` for element-wise comparison of 2 arrays; when
``a.shape[0]`` is 2, ``maximum(a[0], a[1])`` is faster than
``amax(a, axis=0)``.
Examples
--------
a = np.arange(4).reshape((2,2))
a
array([[0, 1],
[2, 3]])
np.amax(a) # Maximum of the flattened array
3
np.amax(a, axis=0) # Maxima along the first axis
array([2, 3])
np.amax(a, axis=1) # Maxima along the second axis
array([1, 3])
b = np.arange(5, dtype=np.float)
b[2] = np.NaN
np.amax(b)
nan
np.nanmax(b)
4.0
amin(a, axis=None, out=None, keepdims=False)
Return the minimum of an array or minimum along an axis.
Parameters
----------
a : array_like
Input data.
axis : None or int or tuple of ints, optional
Axis or axes along which to operate. By default, flattened input is
used.
.. versionadded: 1.7.0
If this is a tuple of ints, the minimum is selected over multiple axes,
instead of a single axis or all the axes as before.
out : ndarray, optional
Alternative output array in which to place the result. Must
be of the same shape and buffer length as the expected output.
See `doc.ufuncs` (Section "Output arguments") for more details.
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`.
Returns
-------
amin : ndarray or scalar
Minimum of `a`. If `axis` is None, the result is a scalar value.
If `axis` is given, the result is an array of dimension
``a.ndim - 1``.
See Also
--------
amax :
The maximum value of an array along a given axis, propagating any NaNs.
nanmin :
The minimum value of an array along a given axis, ignoring any NaNs.
minimum :
Element-wise minimum of two arrays, propagating any NaNs.
fmin :
Element-wise minimum of two arrays, ignoring any NaNs.
argmin :
Return the indices of the minimum values.
nanmax, maximum, fmax
Notes
-----
NaN values are propagated, that is if at least one item is NaN, the
corresponding min value will be NaN as well. To ignore NaN values
(MATLAB behavior), please use nanmin.
Don't use `amin` for element-wise comparison of 2 arrays; when
``a.shape[0]`` is 2, ``minimum(a[0], a[1])`` is faster than
``amin(a, axis=0)``.
Examples
--------
a = np.arange(4).reshape((2,2))
a
array([[0, 1],
[2, 3]])
np.amin(a) # Minimum of the flattened array
0
np.amin(a, axis=0) # Minima along the first axis
array([0, 1])
np.amin(a, axis=1) # Minima along the second axis
array([0, 2])
b = np.arange(5, dtype=np.float)
b[2] = np.NaN
np.amin(b)
nan
np.nanmin(b)
0.0
angle(z, deg=0)
Return the angle of the complex argument.
Parameters
----------
z : array_like
A complex number or sequence of complex numbers.
deg : bool, optional
Return angle in degrees if True, radians if False (default).
Returns
-------
angle : ndarray or scalar
The counterclockwise angle from the positive real axis on
the complex plane, with dtype as numpy.float64.
See Also
--------
arctan2
absolute
Examples
--------
np.angle([1.0, 1.0j, 1+1j]) # in radians
array([ 0. , 1.57079633, 0.78539816])
np.angle(1+1j, deg=True) # in degrees
45.0
any(a, axis=None, out=None, keepdims=False)
Test whether any array element along a given axis evaluates to True.
Returns single boolean unless `axis` is not ``None``
Parameters
----------
a : array_like
Input array or object that can be converted to an array.
axis : None or int or tuple of ints, optional
Axis or axes along which a logical OR reduction is performed.
The default (`axis` = `None`) is to perform a logical OR over all
the dimensions 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 a tuple of ints, a reduction is performed on multiple
axes, instead of a single axis or all the axes as before.
out : ndarray, optional
Alternate output array in which to place the result. It must have
the same shape as the expected output and its type is preserved
(e.g., if it is of type float, then it will remain so, returning
1.0 for True and 0.0 for False, regardless of the type of `a`).
See `doc.ufuncs` (Section "Output arguments") for details.
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`.
Returns
-------
any : bool or ndarray
A new boolean or `ndarray` is returned unless `out` is specified,
in which case a reference to `out` is returned.
See Also
--------
ndarray.any : equivalent method
all : Test whether all elements along a given axis evaluate to True.
Notes
-----
Not a Number (NaN), positive infinity and negative infinity evaluate
to `True` because these are not equal to zero.
Examples
--------
np.any([[True, False], [True, True]])
True
np.any([[True, False], [False, False]], axis=0)
array([ True, False], dtype=bool)
np.any([-1, 0, 5])
True
np.any(np.nan)
True
o=np.array([False])
z=np.any([-1, 4, 5], out=o)
z, o
(array([ True], dtype=bool), array([ True], dtype=bool))
# Check now that z is a reference to o
z is o
True
id(z), id(o) # identity of z and o # doctest: +SKIP
(191614240, 191614240)
append(arr, values, axis=None)
Append values to the end of an array.
Parameters
----------
arr : array_like
Values are appended to a copy of this array.
values : array_like
These values are appended to a copy of `arr`. It must be of the
correct shape (the same shape as `arr`, excluding `axis`). If
`axis` is not specified, `values` can be any shape and will be
flattened before use.
axis : int, optional
The axis along which `values` are appended. If `axis` is not
given, both `arr` and `values` are flattened before use.
Returns
-------
append : ndarray
A copy of `arr` with `values` appended to `axis`. Note that
`append` does not occur in-place: a new array is allocated and
filled. If `axis` is None, `out` is a flattened array.
See Also
--------
insert : Insert elements into an array.
delete : Delete elements from an array.
Examples
--------
np.append([1, 2, 3], [[4, 5, 6], [7, 8, 9]])
array([1, 2, 3, 4, 5, 6, 7, 8, 9])
When `axis` is specified, `values` must have the correct shape.
np.append([[1, 2, 3], [4, 5, 6]], [[7, 8, 9]], axis=0)
array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
np.append([[1, 2, 3], [4, 5, 6]], [7, 8, 9], axis=0)
Traceback (most recent call last):
...
ValueError: arrays must have same number of dimensions
apply_along_axis(func1d, axis, arr, *args, **kwargs)
Apply a function to 1-D slices along the given axis.
Execute `func1d(a, *args)` where `func1d` operates on 1-D arrays and `a`
is a 1-D slice of `arr` along `axis`.
Parameters
----------
func1d : function
This function should accept 1-D arrays. It is applied to 1-D
slices of `arr` along the specified axis.
axis : integer
Axis along which `arr` is sliced.
arr : ndarray
Input array.
args : any
Additional arguments to `func1d`.
kwargs: any
Additional named arguments to `func1d`.
.. versionadded:: 1.9.0
Returns
-------
apply_along_axis : ndarray
The output array. The shape of `outarr` is identical to the shape of
`arr`, except along the `axis` dimension, where the length of `outarr`
is equal to the size of the return value of `func1d`. If `func1d`
returns a scalar `outarr` will have one fewer dimensions than `arr`.
See Also
--------
apply_over_axes : Apply a function repeatedly over multiple axes.
Examples
--------
def my_func(a):
"""Average first and last element of a 1-D array"""
return (a[0] + a[-1]) * 0.5
b = np.array([[1,2,3], [4,5,6], [7,8,9]])
np.apply_along_axis(my_func, 0, b)
array([ 4., 5., 6.])
np.apply_along_axis(my_func, 1, b)
array([ 2., 5., 8.])
For a function that doesn't return a scalar, the number of dimensions in
`outarr` is the same as `arr`.
b = np.array([[8,1,7], [4,3,9], [5,2,6]])
np.apply_along_axis(sorted, 1, b)
array([[1, 7, 8],
[3, 4, 9],
[2, 5, 6]])
apply_over_axes(func, a, axes)
Apply a function repeatedly over multiple axes.
`func` is called as `res = func(a, axis)`, where `axis` is the first
element of `axes`. The result `res` of the function call must have
either the same dimensions as `a` or one less dimension. If `res`
has one less dimension than `a`, a dimension is inserted before
`axis`. The call to `func` is then repeated for each axis in `axes`,
with `res` as the first argument.
Parameters
----------
func : function
This function must take two arguments, `func(a, axis)`.
a : array_like
Input array.
axes : array_like
Axes over which `func` is applied; the elements must be integers.
Returns
-------
apply_over_axis : ndarray
The output array. The number of dimensions is the same as `a`,
but the shape can be different. This depends on whether `func`
changes the shape of its output with respect to its input.
See Also
--------
apply_along_axis :
Apply a function to 1-D slices of an array along the given axis.
Notes
------
This function is equivalent to tuple axis arguments to reorderable ufuncs
with keepdims=True. Tuple axis arguments to ufuncs have been availabe since
version 1.7.0.
Examples
--------
a = np.arange(24).reshape(2,3,4)
a
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]]])
Sum over axes 0 and 2. The result has same number of dimensions
as the original array:
np.apply_over_axes(np.sum, a, [0,2])
array([[[ 60],
[ 92],
[124]]])
Tuple axis arguments to ufuncs are equivalent:
np.sum(a, axis=(0,2), keepdims=True)
array([[[ 60],
[ 92],
[124]]])
arange(...)
arange([start,] stop[, step,], dtype=None)
Return evenly spaced values within a given interval.
Values are generated within the half-open interval ``[start, stop)``
(in other words, the interval including `start` but excluding `stop`).
For integer arguments the function is equivalent to the Python built-in
`range <http://docs.python.org/lib/built-in-funcs.html>`_ function,
but returns an ndarray rather than a list.
When using a non-integer step, such as 0.1, the results will often not
be consistent. It is better to use ``linspace`` for these cases.
Parameters
----------
start : number, optional
Start of interval. The interval includes this value. The default
start value is 0.
stop : number
End of interval. The interval does not include this value, except
in some cases where `step` is not an integer and floating point
round-off affects the length of `out`.
step : number, optional
Spacing between values. For any output `out`, this is the distance
between two adjacent values, ``out[i+1] - out[i]``. The default
step size is 1. If `step` is specified, `start` must also be given.
dtype : dtype
The type of the output array. If `dtype` is not given, infer the data
type from the other input arguments.
Returns
-------
arange : ndarray
Array of evenly spaced values.
For floating point arguments, the length of the result is
``ceil((stop - start)/step)``. Because of floating point overflow,
this rule may result in the last element of `out` being greater
than `stop`.
See Also
--------
linspace : Evenly spaced numbers with careful handling of endpoints.
ogrid: Arrays of evenly spaced numbers in N-dimensions.
mgrid: Grid-shaped arrays of evenly spaced numbers in N-dimensions.
Examples
--------
np.arange(3)
array([0, 1, 2])
np.arange(3.0)
array([ 0., 1., 2.])
np.arange(3,7)
array([3, 4, 5, 6])
np.arange(3,7,2)
array([3, 5])
argmax(a, axis=None, out=None)
Returns the indices of the maximum values along an axis.
Parameters
----------
a : array_like
Input array.
axis : int, optional
By default, the index is into the flattened array, otherwise
along the specified axis.
out : array, optional
If provided, the result will be inserted into this array. It should
be of the appropriate shape and dtype.
Returns
-------
index_array : ndarray of ints
Array of indices into the array. It has the same shape as `a.shape`
with the dimension along `axis` removed.
See Also
--------
ndarray.argmax, argmin
amax : The maximum value along a given axis.
unravel_index : Convert a flat index into an index tuple.
Notes
-----
In case of multiple occurrences of the maximum values, the indices
corresponding to the first occurrence are returned.
Examples
--------
a = np.arange(6).reshape(2,3)
a
array([[0, 1, 2],
[3, 4, 5]])
np.argmax(a)
5
np.argmax(a, axis=0)
array([1, 1, 1])
np.argmax(a, axis=1)
array([2, 2])
b = np.arange(6)
b[1] = 5
b
array([0, 5, 2, 3, 4, 5])
np.argmax(b) # Only the first occurrence is returned.
1
argmin(a, axis=None, out=None)
Returns the indices of the minimum values along an axis.
Parameters
----------
a : array_like
Input array.
axis : int, optional
By default, the index is into the flattened array, otherwise
along the specified axis.
out : array, optional
If provided, the result will be inserted into this array. It should
be of the appropriate shape and dtype.
Returns
-------
index_array : ndarray of ints
Array of indices into the array. It has the same shape as `a.shape`
with the dimension along `axis` removed.
See Also
--------
ndarray.argmin, argmax
amin : The minimum value along a given axis.
unravel_index : Convert a flat index into an index tuple.
Notes
-----
In case of multiple occurrences of the minimum values, the indices
corresponding to the first occurrence are returned.
Examples
--------
a = np.arange(6).reshape(2,3)
a
array([[0, 1, 2],
[3, 4, 5]])
np.argmin(a)
0
np.argmin(a, axis=0)
array([0, 0, 0])
np.argmin(a, axis=1)
array([0, 0])
b = np.arange(6)
b[4] = 0
b
array([0, 1, 2, 3, 0, 5])
np.argmin(b) # Only the first occurrence is returned.
0
argpartition(a, kth, axis=-1, kind='introselect', order=None)
Perform an indirect partition along the given axis using the algorithm
specified by the `kind` keyword. It returns an array of indices of the
same shape as `a` that index data along the given axis in partitioned
order.
.. versionadded:: 1.8.0
Parameters
----------
a : array_like
Array to sort.
kth : int or sequence of ints
Element index to partition by. The kth element will be in its final
sorted position and all smaller elements will be moved before it and
all larger elements behind it.
The order all elements in the partitions is undefined.
If provided with a sequence of kth it will partition all of them into
their sorted position at once.
axis : int or None, optional
Axis along which to sort. The default is -1 (the last axis). If None,
the flattened array is used.
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.
Returns
-------
index_array : ndarray, int
Array of indices that partition `a` along the specified axis.
In other words, ``a[index_array]`` yields a sorted `a`.
See Also
--------
partition : Describes partition algorithms used.
ndarray.partition : Inplace partition.
argsort : Full indirect sort
Notes
-----
See `partition` for notes on the different selection algorithms.
Examples
--------
One dimensional array:
x = np.array([3, 4, 2, 1])
x[np.argpartition(x, 3)]
array([2, 1, 3, 4])
x[np.argpartition(x, (1, 3))]
array([1, 2, 3, 4])
x = [3, 4, 2, 1]
np.array(x)[np.argpartition(x, 3)]
array([2, 1, 3, 4])
argsort(a, axis=-1, kind='quicksort', order=None)
Returns the indices that would sort an array.
Perform an indirect sort along the given axis using the algorithm specified
by the `kind` keyword. It returns an array of indices of the same shape as
`a` that index data along the given axis in sorted order.
Parameters
----------
a : array_like
Array to sort.
axis : int or None, optional
Axis along which to sort. The default is -1 (the last axis). If None,
the flattened array is used.
kind : {'quicksort', 'mergesort', 'heapsort'}, optional
Sorting algorithm.
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.
Returns
-------
index_array : ndarray, int
Array of indices that sort `a` along the specified axis.
In other words, ``a[index_array]`` yields a sorted `a`.
See Also
--------
sort : Describes sorting algorithms used.
lexsort : Indirect stable sort with multiple keys.
ndarray.sort : Inplace sort.
argpartition : Indirect partial sort.
Notes
-----
See `sort` for notes on the different sorting algorithms.
As of NumPy 1.4.0 `argsort` works with real/complex arrays containing
nan values. The enhanced sort order is documented in `sort`.
Examples
--------
One dimensional array:
x = np.array([3, 1, 2])
np.argsort(x)
array([1, 2, 0])
Two-dimensional array:
x = np.array([[0, 3], [2, 2]])
x
array([[0, 3],
[2, 2]])
np.argsort(x, axis=0)
array([[0, 1],
[1, 0]])
np.argsort(x, axis=1)
array([[0, 1],
[0, 1]])
Sorting with keys:
x = np.array([(1, 0), (0, 1)], dtype=[('x', '<i4'), ('y', '<i4')])
x
array([(1, 0), (0, 1)],
dtype=[('x', '<i4'), ('y', '<i4')])
np.argsort(x, order=('x','y'))
array([1, 0])
np.argsort(x, order=('y','x'))
array([0, 1])
argwhere(a)
Find the indices of array elements that are non-zero, grouped by element.
Parameters
----------
a : array_like
Input data.
Returns
-------
index_array : ndarray
Indices of elements that are non-zero. Indices are grouped by element.
See Also
--------
where, nonzero
Notes
-----
``np.argwhere(a)`` is the same as ``np.transpose(np.nonzero(a))``.
The output of ``argwhere`` is not suitable for indexing arrays.
For this purpose use ``where(a)`` instead.
Examples
--------
x = np.arange(6).reshape(2,3)
x
array([[0, 1, 2],
[3, 4, 5]])
np.argwhere(x>1)
array([[0, 2],
[1, 0],
[1, 1],
[1, 2]])
around(a, decimals=0, out=None)
Evenly round to the given number of decimals.
Parameters
----------
a : array_like
Input data.
decimals : int, optional
Number of decimal places to round to (default: 0). If
decimals is negative, it specifies the number of positions to
the left of the decimal point.
out : ndarray, optional
Alternative output array in which to place the result. It must have
the same shape as the expected output, but the type of the output
values will be cast if necessary. See `doc.ufuncs` (Section
"Output arguments") for details.
Returns
-------
rounded_array : ndarray
An array of the same type as `a`, containing the rounded values.
Unless `out` was specified, a new array is created. A reference to
the result is returned.
The real and imaginary parts of complex numbers are rounded
separately. The result of rounding a float is a float.
See Also
--------
ndarray.round : equivalent method
ceil, fix, floor, rint, trunc
Notes
-----
For values exactly halfway between rounded decimal values, Numpy
rounds to the nearest even value. Thus 1.5 and 2.5 round to 2.0,
-0.5 and 0.5 round to 0.0, etc. Results may also be surprising due
to the inexact representation of decimal fractions in the IEEE
floating point standard [1]_ and errors introduced when scaling
by powers of ten.
References
----------
.. [1] "Lecture Notes on the Status of IEEE 754", William Kahan,
http://www.cs.berkeley.edu/~wkahan/ieee754status/IEEE754.PDF
.. [2] "How Futile are Mindless Assessments of
Roundoff in Floating-Point Computation?", William Kahan,
http://www.cs.berkeley.edu/~wkahan/Mindless.pdf
Examples
--------
np.around([0.37, 1.64])
array([ 0., 2.])
np.around([0.37, 1.64], decimals=1)
array([ 0.4, 1.6])
np.around([.5, 1.5, 2.5, 3.5, 4.5]) # rounds to nearest even value
array([ 0., 2., 2., 4., 4.])
np.around([1,2,3,11], decimals=1) # ndarray of ints is returned
array([ 1, 2, 3, 11])
np.around([1,2,3,11], decimals=-1)
array([ 0, 0, 0, 10])
array(...)
array(object, dtype=None, copy=True, order=None, subok=False, ndmin=0)
Create an array.
Parameters
----------
object : array_like
An array, any object exposing the array interface, an
object whose __array__ method returns an array, or any
(nested) sequence.
dtype : data-type, optional
The desired data-type for the array. If not given, then
the type will be determined as the minimum type required
to hold the objects in the sequence. This argument can only
be used to 'upcast' the array. For downcasting, use the
.astype(t) method.
copy : bool, optional
If true (default), then the object is copied. Otherwise, a copy
will only be made if __array__ returns a copy, if obj is a
nested sequence, or if a copy is needed to satisfy any of the other
requirements (`dtype`, `order`, etc.).
order : {'C', 'F', 'A'}, optional
Specify the order of the array. If order is 'C', then the array
will be in C-contiguous order (last-index varies the fastest).
If order is 'F', then the returned array will be in
Fortran-contiguous order (first-index varies the fastest).
If order is 'A' (default), then the returned array may be
in any order (either C-, Fortran-contiguous, or even discontiguous),
unless a copy is required, in which case it will be C-contiguous.
subok : bool, optional
If True, then sub-classes will be passed-through, otherwise
the returned array will be forced to be a base-class array (default).
ndmin : int, optional
Specifies the minimum number of dimensions that the resulting
array should have. Ones will be pre-pended to the shape as
needed to meet this requirement.
Returns
-------
out : ndarray
An array object satisfying the specified requirements.
See Also
--------
empty, empty_like, zeros, zeros_like, ones, ones_like, fill
Examples
--------
np.array([1, 2, 3])
array([1, 2, 3])
Upcasting:
np.array([1, 2, 3.0])
array([ 1., 2., 3.])
More than one dimension:
np.array([[1, 2], [3, 4]])
array([[1, 2],
[3, 4]])
Minimum dimensions 2:
np.array([1, 2, 3], ndmin=2)
array([[1, 2, 3]])
Type provided:
np.array([1, 2, 3], dtype=complex)
array([ 1.+0.j, 2.+0.j, 3.+0.j])
Data-type consisting of more than one element:
x = np.array([(1,2),(3,4)],dtype=[('a','<i4'),('b','<i4')])
x['a']
array([1, 3])
Creating an array from sub-classes:
np.array(np.mat('1 2; 3 4'))
array([[1, 2],
[3, 4]])
np.array(np.mat('1 2; 3 4'), subok=True)
matrix([[1, 2],
[3, 4]])
array2string(a, max_line_width=None, precision=None, suppress_small=None, separator=' ', prefix='', style=<built-in function repr>, formatter=None)
Return a string representation of an array.
Parameters
----------
a : ndarray
Input array.
max_line_width : int, optional
The maximum number of columns the string should span. Newline
characters splits the string appropriately after array elements.
precision : int, optional
Floating point precision. Default is the current printing
precision (usually 8), which can be altered using `set_printoptions`.
suppress_small : bool, optional
Represent very small numbers as zero. A number is "very small" if it
is smaller than the current printing precision.
separator : str, optional
Inserted between elements.
prefix : str, optional
An array is typically printed as::
'prefix(' + array2string(a) + ')'
The length of the prefix string is used to align the
output correctly.
style : function, optional
A function that accepts an ndarray and returns a string. Used only
when the shape of `a` is equal to ``()``, i.e. for 0-D arrays.
formatter : dict of callables, optional
If not None, the keys should indicate the type(s) that the respective
formatting function applies to. Callables should return a string.
Types that are not specified (by their corresponding keys) are handled
by the default formatters. Individual types for which a formatter
can be set are::
- 'bool'
- 'int'
- 'timedelta' : a `numpy.timedelta64`
- 'datetime' : a `numpy.datetime64`
- 'float'
- 'longfloat' : 128-bit floats
- 'complexfloat'
- 'longcomplexfloat' : composed of two 128-bit floats
- 'numpy_str' : types `numpy.string_` and `numpy.unicode_`
- 'str' : all other strings
Other keys that can be used to set a group of types at once are::
- 'all' : sets all types
- 'int_kind' : sets 'int'
- 'float_kind' : sets 'float' and 'longfloat'
- 'complex_kind' : sets 'complexfloat' and 'longcomplexfloat'
- 'str_kind' : sets 'str' and 'numpystr'
Returns
-------
array_str : str
String representation of the array.
Raises
------
TypeError
if a callable in `formatter` does not return a string.
See Also
--------
array_str, array_repr, set_printoptions, get_printoptions
Notes
-----
If a formatter is specified for a certain type, the `precision` keyword is
ignored for that type.
This is a very flexible function; `array_repr` and `array_str` are using
`array2string` internally so keywords with the same name should work
identically in all three functions.
Examples
--------
x = np.array([1e-16,1,2,3])
print np.array2string(x, precision=2, separator=',',
suppress_small=True)
[ 0., 1., 2., 3.]
x = np.arange(3.)
np.array2string(x, formatter={'float_kind':lambda x: "%.2f" % x})
'[0.00 1.00 2.00]'
x = np.arange(3)
np.array2string(x, formatter={'int':lambda x: hex(x)})
'[0x0L 0x1L 0x2L]'
array_equal(a1, a2)
True if two arrays have the same shape and elements, False otherwise.
Parameters
----------
a1, a2 : array_like
Input arrays.
Returns
-------
b : bool
Returns True if the arrays are equal.
See Also
--------
allclose: Returns True if two arrays are element-wise equal within a
tolerance.
array_equiv: Returns True if input arrays are shape consistent and all
elements equal.
Examples
--------
np.array_equal([1, 2], [1, 2])
True
np.array_equal(np.array([1, 2]), np.array([1, 2]))
True
np.array_equal([1, 2], [1, 2, 3])
False
np.array_equal([1, 2], [1, 4])
False
array_equiv(a1, a2)
Returns True if input arrays are shape consistent and all elements equal.
Shape consistent means they are either the same shape, or one input array
can be broadcasted to create the same shape as the other one.
Parameters
----------
a1, a2 : array_like
Input arrays.
Returns
-------
out : bool
True if equivalent, False otherwise.
Examples
--------
np.array_equiv([1, 2], [1, 2])
True
np.array_equiv([1, 2], [1, 3])
False
Showing the shape equivalence:
np.array_equiv([1, 2], [[1, 2], [1, 2]])
True
np.array_equiv([1, 2], [[1, 2, 1, 2], [1, 2, 1, 2]])
False
np.array_equiv([1, 2], [[1, 2], [1, 3]])
False
array_repr(arr, max_line_width=None, precision=None, suppress_small=None)
Return the string representation of an array.
Parameters
----------
arr : ndarray
Input array.
max_line_width : int, optional
The maximum number of columns the string should span. Newline
characters split the string appropriately after array elements.
precision : int, optional
Floating point precision. Default is the current printing precision
(usually 8), which can be altered using `set_printoptions`.
suppress_small : bool, optional
Represent very small numbers as zero, default is False. Very small
is defined by `precision`, if the precision is 8 then
numbers smaller than 5e-9 are represented as zero.
Returns
-------
string : str
The string representation of an array.
See Also
--------
array_str, array2string, set_printoptions
Examples
--------
np.array_repr(np.array([1,2]))
'array([1, 2])'
np.array_repr(np.ma.array([0.]))
'MaskedArray([ 0.])'
np.array_repr(np.array([], np.int32))
'array([], dtype=int32)'
x = np.array([1e-6, 4e-7, 2, 3])
np.array_repr(x, precision=6, suppress_small=True)
'array([ 0.000001, 0. , 2. , 3. ])'
array_split(ary, indices_or_sections, axis=0)
Split an array into multiple sub-arrays.
Please refer to the ``split`` documentation. The only difference
between these functions is that ``array_split`` allows
`indices_or_sections` to be an integer that does *not* equally
divide the axis.
See Also
--------
split : Split array into multiple sub-arrays of equal size.
Examples
--------
x = np.arange(8.0)
np.array_split(x, 3)
[array([ 0., 1., 2.]), array([ 3., 4., 5.]), array([ 6., 7.])]
array_str(a, max_line_width=None, precision=None, suppress_small=None)
Return a string representation of the data in an array.
The data in the array is returned as a single string. This function is
similar to `array_repr`, the difference being that `array_repr` also
returns information on the kind of array and its data type.
Parameters
----------
a : ndarray
Input array.
max_line_width : int, optional
Inserts newlines if text is longer than `max_line_width`. The
default is, indirectly, 75.
precision : int, optional
Floating point precision. Default is the current printing precision
(usually 8), which can be altered using `set_printoptions`.
suppress_small : bool, optional
Represent numbers "very close" to zero as zero; default is False.
Very close is defined by precision: if the precision is 8, e.g.,
numbers smaller (in absolute value) than 5e-9 are represented as
zero.
See Also
--------
array2string, array_repr, set_printoptions
Examples
--------
np.array_str(np.arange(3))
'[0 1 2]'
asanyarray(a, dtype=None, order=None)
Convert the input to an ndarray, but pass ndarray subclasses through.
Parameters
----------
a : array_like
Input data, in any form that can be converted to an array. This
includes scalars, lists, lists of tuples, tuples, tuples of tuples,
tuples of lists, and ndarrays.
dtype : data-type, optional
By default, the data-type is inferred from the input data.
order : {'C', 'F'}, optional
Whether to use row-major (C-style) or column-major
(Fortran-style) memory representation. Defaults to 'C'.
Returns
-------
out : ndarray or an ndarray subclass
Array interpretation of `a`. If `a` is an ndarray or a subclass
of ndarray, it is returned as-is and no copy is performed.
See Also
--------
asarray : Similar function which always returns ndarrays.
ascontiguousarray : Convert input to a contiguous array.
asfarray : Convert input to a floating point ndarray.
asfortranarray : Convert input to an ndarray with column-major
memory order.
asarray_chkfinite : Similar function which checks input for NaNs and
Infs.
fromiter : Create an array from an iterator.
fromfunction : Construct an array by executing a function on grid
positions.
Examples
--------
Convert a list into an array:
a = [1, 2]
np.asanyarray(a)
array([1, 2])
Instances of `ndarray` subclasses are passed through as-is:
a = np.matrix([1, 2])
np.asanyarray(a) is a
True
asarray(a, dtype=None, order=None)
Convert the input to an array.
Parameters
----------
a : array_like
Input data, in any form that can be converted to an array. This
includes lists, lists of tuples, tuples, tuples of tuples, tuples
of lists and ndarrays.
dtype : data-type, optional
By default, the data-type is inferred from the input data.
order : {'C', 'F'}, optional
Whether to use row-major (C-style) or
column-major (Fortran-style) memory representation.
Defaults to 'C'.
Returns
-------
out : ndarray
Array interpretation of `a`. No copy is performed if the input
is already an ndarray. If `a` is a subclass of ndarray, a base
class ndarray is returned.
See Also
--------
asanyarray : Similar function which passes through subclasses.
ascontiguousarray : Convert input to a contiguous array.
asfarray : Convert input to a floating point ndarray.
asfortranarray : Convert input to an ndarray with column-major
memory order.
asarray_chkfinite : Similar function which checks input for NaNs and Infs.
fromiter : Create an array from an iterator.
fromfunction : Construct an array by executing a function on grid
positions.
Examples
--------
Convert a list into an array:
a = [1, 2]
np.asarray(a)
array([1, 2])
Existing arrays are not copied:
a = np.array([1, 2])
np.asarray(a) is a
True
If `dtype` is set, array is copied only if dtype does not match:
a = np.array([1, 2], dtype=np.float32)
np.asarray(a, dtype=np.float32) is a
True
np.asarray(a, dtype=np.float64) is a
False
Contrary to `asanyarray`, ndarray subclasses are not passed through:
issubclass(np.matrix, np.ndarray)
True
a = np.matrix([[1, 2]])
np.asarray(a) is a
False
np.asanyarray(a) is a
True
asarray_chkfinite(a, dtype=None, order=None)
Convert the input to an array, checking for NaNs or Infs.
Parameters
----------
a : array_like
Input data, in any form that can be converted to an array. This
includes lists, lists of tuples, tuples, tuples of tuples, tuples
of lists and ndarrays. Success requires no NaNs or Infs.
dtype : data-type, optional
By default, the data-type is inferred from the input data.
order : {'C', 'F'}, optional
Whether to use row-major (C-style) or
column-major (Fortran-style) memory representation.
Defaults to 'C'.
Returns
-------
out : ndarray
Array interpretation of `a`. No copy is performed if the input
is already an ndarray. If `a` is a subclass of ndarray, a base
class ndarray is returned.
Raises
------
ValueError
Raises ValueError if `a` contains NaN (Not a Number) or Inf (Infinity).
See Also
--------
asarray : Create and array.
asanyarray : Similar function which passes through subclasses.
ascontiguousarray : Convert input to a contiguous array.
asfarray : Convert input to a floating point ndarray.
asfortranarray : Convert input to an ndarray with column-major
memory order.
fromiter : Create an array from an iterator.
fromfunction : Construct an array by executing a function on grid
positions.
Examples
--------
Convert a list into an array. If all elements are finite
``asarray_chkfinite`` is identical to ``asarray``.
a = [1, 2]
np.asarray_chkfinite(a, dtype=float)
array([1., 2.])
Raises ValueError if array_like contains Nans or Infs.
a = [1, 2, np.inf]
try:
np.asarray_chkfinite(a)
except ValueError:
print 'ValueError'
...
ValueError
ascontiguousarray(a, dtype=None)
Return a contiguous array in memory (C order).
Parameters
----------
a : array_like
Input array.
dtype : str or dtype object, optional
Data-type of returned array.
Returns
-------
out : ndarray
Contiguous array of same shape and content as `a`, with type `dtype`
if specified.
See Also
--------
asfortranarray : Convert input to an ndarray with column-major
memory order.
require : Return an ndarray that satisfies requirements.
ndarray.flags : Information about the memory layout of the array.
Examples
--------
x = np.arange(6).reshape(2,3)
np.ascontiguousarray(x, dtype=np.float32)
array([[ 0., 1., 2.],
[ 3., 4., 5.]], dtype=float32)
x.flags['C_CONTIGUOUS']
True
asfarray(a, dtype=<type 'numpy.float64'>)
Return an array converted to a float type.
Parameters
----------
a : array_like
The input array.
dtype : str or dtype object, optional
Float type code to coerce input array `a`. If `dtype` is one of the
'int' dtypes, it is replaced with float64.
Returns
-------
out : ndarray
The input `a` as a float ndarray.
Examples
--------
np.asfarray([2, 3])
array([ 2., 3.])
np.asfarray([2, 3], dtype='float')
array([ 2., 3.])
np.asfarray([2, 3], dtype='int8')
array([ 2., 3.])
asfortranarray(a, dtype=None)
Return an array laid out in Fortran order in memory.
Parameters
----------
a : array_like
Input array.
dtype : str or dtype object, optional
By default, the data-type is inferred from the input data.
Returns
-------
out : ndarray
The input `a` in Fortran, or column-major, order.
See Also
--------
ascontiguousarray : Convert input to a contiguous (C order) array.
asanyarray : Convert input to an ndarray with either row or
column-major memory order.
require : Return an ndarray that satisfies requirements.
ndarray.flags : Information about the memory layout of the array.
Examples
--------
x = np.arange(6).reshape(2,3)
y = np.asfortranarray(x)
x.flags['F_CONTIGUOUS']
False
y.flags['F_CONTIGUOUS']
True
asmatrix(data, dtype=None)
Interpret the input as a matrix.
Unlike `matrix`, `asmatrix` does not make a copy if the input is already
a matrix or an ndarray. Equivalent to ``matrix(data, copy=False)``.
Parameters
----------
data : array_like
Input data.
dtype : data-type
Data-type of the output matrix.
Returns
-------
mat : matrix
`data` interpreted as a matrix.
Examples
--------
x = np.array([[1, 2], [3, 4]])
m = np.asmatrix(x)
x[0,0] = 5
m
matrix([[5, 2],
[3, 4]])
asscalar(a)
Convert an array of size 1 to its scalar equivalent.
Parameters
----------
a : ndarray
Input array of size 1.
Returns
-------
out : scalar
Scalar representation of `a`. The output data type is the same type
returned by the input's `item` method.
Examples
--------
np.asscalar(np.array([24]))
24
atleast_1d(*arys)
Convert inputs to arrays with at least one dimension.
Scalar inputs are converted to 1-dimensional arrays, whilst
higher-dimensional inputs are preserved.
Parameters
----------
arys1, arys2, ... : array_like
One or more input arrays.
Returns
-------
ret : ndarray
An array, or sequence of arrays, each with ``a.ndim >= 1``.
Copies are made only if necessary.
See Also
--------
atleast_2d, atleast_3d
Examples
--------
np.atleast_1d(1.0)
array([ 1.])
x = np.arange(9.0).reshape(3,3)
np.atleast_1d(x)
array([[ 0., 1., 2.],
[ 3., 4., 5.],
[ 6., 7., 8.]])
np.atleast_1d(x) is x
True
np.atleast_1d(1, [3, 4])
[array([1]), array([3, 4])]
atleast_2d(*arys)
View inputs as arrays with at least two dimensions.
Parameters
----------
arys1, arys2, ... : array_like
One or more array-like sequences. Non-array inputs are converted
to arrays. Arrays that already have two or more dimensions are
preserved.
Returns
-------
res, res2, ... : ndarray
An array, or tuple of arrays, each with ``a.ndim >= 2``.
Copies are avoided where possible, and views with two or more
dimensions are returned.
See Also
--------
atleast_1d, atleast_3d
Examples
--------
np.atleast_2d(3.0)
array([[ 3.]])
x = np.arange(3.0)
np.atleast_2d(x)
array([[ 0., 1., 2.]])
np.atleast_2d(x).base is x
True
np.atleast_2d(1, [1, 2], [[1, 2]])
[array([[1]]), array([[1, 2]]), array([[1, 2]])]
atleast_3d(*arys)
View inputs as arrays with at least three dimensions.
Parameters
----------
arys1, arys2, ... : array_like
One or more array-like sequences. Non-array inputs are converted to
arrays. Arrays that already have three or more dimensions are
preserved.
Returns
-------
res1, res2, ... : ndarray
An array, or tuple of arrays, each with ``a.ndim >= 3``. Copies are
avoided where possible, and views with three or more dimensions are
returned. For example, a 1-D array of shape ``(N,)`` becomes a view
of shape ``(1, N, 1)``, and a 2-D array of shape ``(M, N)`` becomes a
view of shape ``(M, N, 1)``.
See Also
--------
atleast_1d, atleast_2d
Examples
--------
np.atleast_3d(3.0)
array([[[ 3.]]])
x = np.arange(3.0)
np.atleast_3d(x).shape
(1, 3, 1)
x = np.arange(12.0).reshape(4,3)
np.atleast_3d(x).shape
(4, 3, 1)
np.atleast_3d(x).base is x
True
for arr in np.atleast_3d([1, 2], [[1, 2]], [[[1, 2]]]):
print arr, arr.shape
...
[[[1]
[2]]] (1, 2, 1)
[[[1]
[2]]] (1, 2, 1)
[[[1 2]]] (1, 1, 2)
average(a, axis=None, weights=None, returned=False)
Compute the weighted average along the specified axis.
Parameters
----------
a : array_like
Array containing data to be averaged. If `a` is not an array, a
conversion is attempted.
axis : int, optional
Axis along which to average `a`. If `None`, averaging is done over
the flattened array.
weights : array_like, optional
An array of weights associated with the values in `a`. Each value in
`a` contributes to the average according to its associated weight.
The weights array can either be 1-D (in which case its length must be
the size of `a` along the given axis) or of the same shape as `a`.
If `weights=None`, then all data in `a` are assumed to have a
weight equal to one.
returned : bool, optional
Default is `False`. If `True`, the tuple (`average`, `sum_of_weights`)
is returned, otherwise only the average is returned.
If `weights=None`, `sum_of_weights` is equivalent to the number of
elements over which the average is taken.
Returns
-------
average, [sum_of_weights] : array_type or double
Return the average along the specified axis. When returned is `True`,
return a tuple with the average as the first element and the sum
of the weights as the second element. The return type is `Float`
if `a` is of integer type, otherwise it is of the same type as `a`.
`sum_of_weights` is of the same type as `average`.
Raises
------
ZeroDivisionError
When all weights along axis are zero. See `numpy.ma.average` for a
version robust to this type of error.
TypeError
When the length of 1D `weights` is not the same as the shape of `a`
along axis.
See Also
--------
mean
ma.average : average for masked arrays -- useful if your data contains
"missing" values
Examples
--------
data = range(1,5)
data
[1, 2, 3, 4]
np.average(data)
2.5
np.average(range(1,11), weights=range(10,0,-1))
4.0
data = np.arange(6).reshape((3,2))
data
array([[0, 1],
[2, 3],
[4, 5]])
np.average(data, axis=1, weights=[1./4, 3./4])
array([ 0.75, 2.75, 4.75])
np.average(data, weights=[1./4, 3./4])
Traceback (most recent call last):
...
TypeError: Axis must be specified when shapes of a and weights differ.
bartlett(M)
Return the Bartlett window.
The Bartlett window is very similar to a triangular window, except
that the end points are at zero. It is often used in signal
processing for tapering a signal, without generating too much
ripple in the frequency domain.
Parameters
----------
M : int
Number of points in the output window. If zero or less, an
empty array is returned.
Returns
-------
out : array
The triangular window, with the maximum value normalized to one
(the value one appears only if the number of samples is odd), with
the first and last samples equal to zero.
See Also
--------
blackman, hamming, hanning, kaiser
Notes
-----
The Bartlett window is defined as
.. math:: w(n) = \frac{2}{M-1} \left(
\frac{M-1}{2} - \left|n - \frac{M-1}{2}\right|
\right)
Most references to the Bartlett window come from the signal
processing literature, where it is used as one of many windowing
functions for smoothing values. Note that convolution with this
window produces linear interpolation. It is also known as an
apodization (which means"removing the foot", i.e. smoothing
discontinuities at the beginning and end of the sampled signal) or
tapering function. The fourier transform of the Bartlett is the product
of two sinc functions.
Note the excellent discussion in Kanasewich.
References
----------
.. [1] M.S. Bartlett, "Periodogram Analysis and Continuous Spectra",
Biometrika 37, 1-16, 1950.
.. [2] E.R. Kanasewich, "Time Sequence Analysis in Geophysics",
The University of Alberta Press, 1975, pp. 109-110.
.. [3] A.V. Oppenheim and R.W. Schafer, "Discrete-Time Signal
Processing", Prentice-Hall, 1999, pp. 468-471.
.. [4] Wikipedia, "Window function",
http://en.wikipedia.org/wiki/Window_function
.. [5] W.H. Press, B.P. Flannery, S.A. Teukolsky, and W.T. Vetterling,
"Numerical Recipes", Cambridge University Press, 1986, page 429.
Examples
--------
np.bartlett(12)
array([ 0. , 0.18181818, 0.36363636, 0.54545455, 0.72727273,
0.90909091, 0.90909091, 0.72727273, 0.54545455, 0.36363636,
0.18181818, 0. ])
Plot the window and its frequency response (requires SciPy and matplotlib):
from numpy.fft import fft, fftshift
window = np.bartlett(51)
plt.plot(window)
[<matplotlib.lines.Line2D object at 0x...>]
plt.title("Bartlett window")
<matplotlib.text.Text object at 0x...>
plt.ylabel("Amplitude")
<matplotlib.text.Text object at 0x...>
plt.xlabel("Sample")
<matplotlib.text.Text object at 0x...>
plt.show()
plt.figure()
<matplotlib.figure.Figure object at 0x...>
A = fft(window, 2048) / 25.5
mag = np.abs(fftshift(A))
freq = np.linspace(-0.5, 0.5, len(A))
response = 20 * np.log10(mag)
response = np.clip(response, -100, 100)
plt.plot(freq, response)
[<matplotlib.lines.Line2D object at 0x...>]
plt.title("Frequency response of Bartlett window")
<matplotlib.text.Text object at 0x...>
plt.ylabel("Magnitude [dB]")
<matplotlib.text.Text object at 0x...>
plt.xlabel("Normalized frequency [cycles per sample]")
<matplotlib.text.Text object at 0x...>
plt.axis('tight')
(-0.5, 0.5, -100.0, ...)
plt.show()
base_repr(number, base=2, padding=0)
Return a string representation of a number in the given base system.
Parameters
----------
number : int
The value to convert. Only positive values are handled.
base : int, optional
Convert `number` to the `base` number system. The valid range is 2-36,
the default value is 2.
padding : int, optional
Number of zeros padded on the left. Default is 0 (no padding).
Returns
-------
out : str
String representation of `number` in `base` system.
See Also
--------
binary_repr : Faster version of `base_repr` for base 2.
Examples
--------
np.base_repr(5)
'101'
np.base_repr(6, 5)
'11'
np.base_repr(7, base=5, padding=3)
'00012'
np.base_repr(10, base=16)
'A'
np.base_repr(32, base=16)
'20'
binary_repr(num, width=None)
Return the binary representation of the input number as a string.
For negative numbers, if width is not given, a minus sign is added to the
front. If width is given, the two's complement of the number is
returned, with respect to that width.
In a two's-complement system negative numbers are represented by the two's
complement of the absolute value. This is the most common method of
representing signed integers on computers [1]_. A N-bit two's-complement
system can represent every integer in the range
:math:`-2^{N-1}` to :math:`+2^{N-1}-1`.
Parameters
----------
num : int
Only an integer decimal number can be used.
width : int, optional
The length of the returned string if `num` is positive, the length of
the two's complement if `num` is negative.
Returns
-------
bin : str
Binary representation of `num` or two's complement of `num`.
See Also
--------
base_repr: Return a string representation of a number in the given base
system.
Notes
-----
`binary_repr` is equivalent to using `base_repr` with base 2, but about 25x
faster.
References
----------
.. [1] Wikipedia, "Two's complement",
http://en.wikipedia.org/wiki/Two's_complement
Examples
--------
np.binary_repr(3)
'11'
np.binary_repr(-3)
'-11'
np.binary_repr(3, width=4)
'0011'
The two's complement is returned when the input number is negative and
width is specified:
np.binary_repr(-3, width=4)
'1101'
bincount(...)
bincount(x, weights=None, minlength=None)
Count number of occurrences of each value in array of non-negative ints.
The number of bins (of size 1) is one larger than the largest value in
`x`. If `minlength` is specified, there will be at least this number
of bins in the output array (though it will be longer if necessary,
depending on the contents of `x`).
Each bin gives the number of occurrences of its index value in `x`.
If `weights` is specified the input array is weighted by it, i.e. if a
value ``n`` is found at position ``i``, ``out[n] += weight[i]`` instead
of ``out[n] += 1``.
Parameters
----------
x : array_like, 1 dimension, nonnegative ints
Input array.
weights : array_like, optional
Weights, array of the same shape as `x`.
minlength : int, optional
A minimum number of bins for the output array.
.. versionadded:: 1.6.0
Returns
-------
out : ndarray of ints
The result of binning the input array.
The length of `out` is equal to ``np.amax(x)+1``.
Raises
------
ValueError
If the input is not 1-dimensional, or contains elements with negative
values, or if `minlength` is non-positive.
TypeError
If the type of the input is float or complex.
See Also
--------
histogram, digitize, unique
Examples
--------
np.bincount(np.arange(5))
array([1, 1, 1, 1, 1])
np.bincount(np.array([0, 1, 1, 3, 2, 1, 7]))
array([1, 3, 1, 1, 0, 0, 0, 1])
x = np.array([0, 1, 1, 3, 2, 1, 7, 23])
np.bincount(x).size == np.amax(x)+1
True
The input array needs to be of integer dtype, otherwise a
TypeError is raised:
np.bincount(np.arange(5, dtype=np.float))
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: array cannot be safely cast to required type
A possible use of ``bincount`` is to perform sums over
variable-size chunks of an array, using the ``weights`` keyword.
w = np.array([0.3, 0.5, 0.2, 0.7, 1., -0.6]) # weights
x = np.array([0, 1, 1, 2, 2, 2])NumPy doc （六）
最新推荐文章于 2022-08-31 15:07:55 发布
扫一扫
2393
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
