numpy (version 1.3.0)
index
/usr/lib/python2.6/dist-packages/numpy/__init__.py

NumPy
=====
 
Provides
  1. An array object of arbitrary homogeneous items
  2. Fast mathematical operations over arrays
  3. Linear Algebra, Fourier Transforms, Random Number Generation
 
How to use the documentation
----------------------------
Documentation is available in two forms: docstrings provided
with the code, and a loose standing reference guide, available from
`the NumPy homepage <http://www.scipy.org>`_.
 
We recommend exploring the docstrings using
`IPython <http://ipython.scipy.org>`_, an advanced Python shell with
TAB-completion and introspection capabilities.  See below for further
instructions.
 
The docstring examples assume that `numpy` has been imported as `np`::
 
  >>> import numpy as np
 
Code snippets are indicated by three greater-than signs::
 
  >>> x = x + 1
 
Use the built-in ``help`` function to view a function's docstring::
 
  >>> help(np.sort)
 
For some objects, ``np.info(obj)`` may provide additional help.  This is
particularly true if you see the line "Help on ufunc object:" at the top
of the help() page.  Ufuncs are implemented in C, not Python, for speed.
The native Python help() does not know how to view their help, but our
np.info() function does.
 
To search for documents containing a keyword, do::
 
  >>> np.lookfor('keyword')
 
General-purpose documents like a glossary and help on the basic concepts
of numpy are available under the ``doc`` sub-module::
 
  >>> from numpy import doc
  >>> help(doc)
 
Available subpackages
---------------------
doc
    Topical documentation on broadcasting, indexing, etc.
lib
    Basic functions used by several sub-packages.
random
    Core Random Tools
linalg
    Core Linear Algebra Tools
fft
    Core FFT routines
testing
    Numpy testing tools
f2py
    Fortran to Python Interface Generator.
distutils
    Enhancements to distutils with support for
    Fortran compilers support and more.
 
Utilities
---------
test
    Run numpy unittests
show_config
    Show numpy build configuration
dual
    Overwrite certain functions with high-performance Scipy tools
matlib
    Make everything matrices.
__version__
    Numpy version string
 
Viewing documentation using IPython
-----------------------------------
Start IPython with the NumPy profile (``ipython -p numpy``), which will
import `numpy` under the alias `np`.  Then, use the ``cpaste`` command to
paste examples into the shell.  To see which functions are available in
`numpy`, type ``np.<TAB>`` (where ``<TAB>`` refers to the TAB key), or use
``np.*cos*?<ENTER>`` (where ``<ENTER>`` refers to the ENTER key) to narrow
down the list.  To view the docstring for a function, use
``np.cos?<ENTER>`` (to view the docstring) and ``np.cos??<ENTER>`` (to view
the source code).
 
Copies vs. in-place operation
-----------------------------
Most of the functions in `numpy` return a copy of the array argument
(e.g., `sort`).  In-place versions of these functions are often
available as array methods, i.e. ``x = np.array([1,2,3]); x.sort()``.
Exceptions to this rule are documented.

 
Package Contents
        __config__
__init__
_import_tools
add_newdocs
core (package) -- Defines a multi-dimensional array and useful procedures for Numerical computation.
ctypeslib
distutils (package) -- Enhanced distutils with Fortran compilers support and more.
dual -- Aliases for functions which may be accelerated by Scipy.
f2py (package) -- Fortran to Python Interface Generator.
fft (package)
lib (package)
linalg (package)
ma (package)
matlib
numarray (package)
oldnumeric (package)
random (package)
setup
setupscons
testing (package) -- Common test support for all numpy test scripts.
version

 
Classes
       
object
broadcast
dtype
flatiter
generic
bool_
bool_
flexible
character
string_(str, character)
string_(str, character)
string_(str, character)
unicode_(unicode, character)
unicode_(unicode, character)
void
void
number
inexact
complexfloating
complex128(complexfloating, complex)
complex128(complexfloating, complex)
complex128(complexfloating, complex)
complex128(complexfloating, complex)
complex256
complex256
complex256
complex256
complex64
complex64
complex64
floating
float128
float128
float128
float32
float32
float64(floating, float)
float64(floating, float)
float64(floating, float)
integer
signedinteger
int16
int16
int32
int32
int64(signedinteger, int)
int64(signedinteger, int)
int64(signedinteger, int)
int64(signedinteger, int)
int64(signedinteger, int)
int8
int8
unsignedinteger
uint16
uint16
uint32
uint32
uint64
uint64
uint64
uint64
uint64
uint8
uint8
object_
object_
ndarray
ufunc
str(basestring)
string_(str, character)
string_(str, character)
string_(str, character)
unicode(basestring)
unicode_(unicode, character)
unicode_(unicode, character)

 
bool8 = class bool_(generic)
    Boolean. Character code ``?``.
 
 
Method resolution order:
bool_
generic
object

Methods defined here:
__and__(...)
x.__and__(y) <==> x&y
__eq__(...)
x.__eq__(y) <==> x==y
__ge__(...)
x.__ge__(y) <==> x>=y
__gt__(...)
x.__gt__(y) <==> x>y
__hash__(...)
x.__hash__() <==> hash(x)
__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
__nonzero__(...)
x.__nonzero__() <==> x != 0
__or__(...)
x.__or__(y) <==> x|y
__rand__(...)
x.__rand__(y) <==> y&x
__ror__(...)
x.__ror__(y) <==> y|x
__rxor__(...)
x.__rxor__(y) <==> y^x
__xor__(...)
x.__xor__(y) <==> x^y

Data and other attributes defined here:
__new__ = <built-in method __new__ of type object at 0x7f8ebc3395e0>
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
__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
__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
__oct__(...)
x.__oct__() <==> oct(x)
__pos__(...)
x.__pos__() <==> +x
__pow__(...)
x.__pow__(y[, z]) <==> pow(x, y[, z])
__radd__(...)
x.__radd__(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
__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
__setstate__(...)
__str__(...)
x.__str__() <==> str(x)
__sub__(...)
x.__sub__(y) <==> x-y
__truediv__(...)
x.__truediv__(y) <==> x/y
all(...)
any(...)
argmax(...)
argmin(...)
argsort(...)
astype(...)
byteswap(...)
choose(...)
clip(...)
compress(...)
conj(...)
conjugate(...)
copy(...)
cumprod(...)
cumsum(...)
diagonal(...)
dump(...)
dumps(...)
fill(...)
flatten(...)
getfield(...)
item(...)
itemset(...)
max(...)
mean(...)
min(...)
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:
 
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
 
Parameters
----------
new_order : string, 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(...)
prod(...)
ptp(...)
put(...)
ravel(...)
repeat(...)
reshape(...)
resize(...)
round(...)
searchsorted(...)
setfield(...)
setflags(...)
sort(...)
squeeze(...)
std(...)
sum(...)
swapaxes(...)
take(...)
tofile(...)
tolist(...)
tostring(...)
trace(...)
transpose(...)
var(...)
view(...)

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 bool_(generic)
    Boolean. Character code ``?``.
 
 
Method resolution order:
bool_
generic
object

Methods defined here:
__and__(...)
x.__and__(y) <==> x&y
__eq__(...)
x.__eq__(y) <==> x==y
__ge__(...)
x.__ge__(y) <==> x>=y
__gt__(...)
x.__gt__(y) <==> x>y
__hash__(...)
x.__hash__() <==> hash(x)
__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
__nonzero__(...)
x.__nonzero__() <==> x != 0
__or__(...)
x.__or__(y) <==> x|y
__rand__(...)
x.__rand__(y) <==> y&x
__ror__(...)
x.__ror__(y) <==> y|x
__rxor__(...)
x.__rxor__(y) <==> y^x
__xor__(...)
x.__xor__(y) <==> x^y

Data and other attributes defined here:
__new__ = <built-in method __new__ of type object at 0x7f8ebc3395e0>
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
__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
__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
__oct__(...)
x.__oct__() <==> oct(x)
__pos__(...)
x.__pos__() <==> +x
__pow__(...)
x.__pow__(y[, z]) <==> pow(x, y[, z])
__radd__(...)
x.__radd__(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
__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
__setstate__(...)
__str__(...)
x.__str__() <==> str(x)
__sub__(...)
x.__sub__(y) <==> x-y
__truediv__(...)
x.__truediv__(y) <==> x/y
all(...)
any(...)
argmax(...)
argmin(...)
argsort(...)
astype(...)
byteswap(...)
choose(...)
clip(...)
compress(...)
conj(...)
conjugate(...)
copy(...)
cumprod(...)
cumsum(...)
diagonal(...)
dump(...)
dumps(...)
fill(...)
flatten(...)
getfield(...)
item(...)
itemset(...)
max(...)
mean(...)
min(...)
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:
 
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
 
Parameters
----------
new_order : string, 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(...)
prod(...)
ptp(...)
put(...)
ravel(...)
repeat(...)
reshape(...)
resize(...)
round(...)
searchsorted(...)
setfield(...)
setflags(...)
sort(...)
squeeze(...)
std(...)
sum(...)
swapaxes(...)
take(...)
tofile(...)
tolist(...)
tostring(...)
trace(...)
transpose(...)
var(...)
view(...)

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 broadcast(object)
    Produce an object that mimics broadcasting.
 
Parameters
----------
in1, in2, ... : array_like
    Input parameters.
 
Returns
-------
b : broadcast object
    Broadcast the input parameters against one another, and
    return an object that encapsulates the result.
    Amongst others, it has ``shape`` and ``nd`` properties, and
    may be used as an iterator.
 
Examples
--------
Manually adding two vectors, using broadcasting:
 
>>> x = np.array([[1], [2], [3]])
>>> y = np.array([4, 5, 6])
>>> b = np.broadcast(x, y)
 
>>> out = np.empty(b.shape)
>>> out.flat = [u+v for (u,v) in b]
>>> out
array([[ 5.,  6.,  7.],
       [ 6.,  7.,  8.],
       [ 7.,  8.,  9.]])
 
Compare against built-in broadcasting:
 
>>> x + y
array([[5, 6, 7],
       [6, 7, 8],
       [7, 8, 9]])
 
  Methods defined here:
__iter__(...)
x.__iter__() <==> iter(x)
next(...)
x.next() -> the next value, or raise StopIteration
reset(...)

Data descriptors defined here:
index
current index in broadcasted result
iters
tuple of individual iterators
nd
number of dimensions of broadcasted result
numiter
number of iterators
shape
shape of broadcasted result
size
total size of broadcasted result

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

 
byte = class int8(signedinteger)
    8-bit integer. Character code ``b``.
 
 
Method resolution order:
int8
signedinteger
integer
number
generic
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 at 0x7f8ebc33a800>
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
__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__(...)
__str__(...)
x.__str__() <==> str(x)
__sub__(...)
x.__sub__(y) <==> x-y
__truediv__(...)
x.__truediv__(y) <==> x/y
__xor__(...)
x.__xor__(y) <==> x^y
all(...)
any(...)
argmax(...)
argmin(...)
argsort(...)
astype(...)
byteswap(...)
choose(...)
clip(...)
compress(...)
conj(...)
conjugate(...)
copy(...)
cumprod(...)
cumsum(...)
diagonal(...)
dump(...)
dumps(...)
fill(...)
flatten(...)
getfield(...)
item(...)
itemset(...)
max(...)
mean(...)
min(...)
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:
 
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
 
Parameters
----------
new_order : string, 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(...)
prod(...)
ptp(...)
put(...)
ravel(...)
repeat(...)
reshape(...)
resize(...)
round(...)
searchsorted(...)
setfield(...)
setflags(...)
sort(...)
squeeze(...)
std(...)
sum(...)
swapaxes(...)
take(...)
tofile(...)
tolist(...)
tostring(...)
trace(...)
transpose(...)
var(...)
view(...)

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

 
cdouble = class complex128(complexfloating, complex)
    Composed of two 64 bit floats
 
 
Method resolution order:
complex128
complexfloating
inexact
number
generic
complex
object

Methods defined here:
__eq__(...)
x.__eq__(y) <==> x==y
__ge__(...)
x.__ge__(y) <==> x>=y
__gt__(...)
x.__gt__(y) <==> x>y
__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 at 0x7f8ebc33bec0>
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
__getitem__(...)
x.__getitem__(y) <==> x[y]
__hex__(...)
x.__hex__() <==> hex(x)
__int__(...)
x.__int__() <==> int(x)
__invert__(...)
x.__invert__() <==> ~x
__long__(...)
x.__long__() <==> long(x)
__lshift__(...)
x.__lshift__(y) <==> x<<y
__mod__(...)
x.__mod__(y) <==> x%y
__mul__(...)
x.__mul__(y) <==> x*y
__neg__(...)
x.__neg__() <==> -x
__nonzero__(...)
x.__nonzero__() <==> x != 0
__oct__(...)
x.__oct__() <==> oct(x)
__or__(...)
x.__or__(y) <==> x|y
__pos__(...)
x.__pos__() <==> +x
__pow__(...)
x.__pow__(y[, z]) <==> pow(x, y[, z])
__radd__(...)
x.__radd__(y) <==> y+x
__rand__(...)
x.__rand__(y) <==> y&x
__rdiv__(...)
x.__rdiv__(y) <==> y/x
__rdivmod__(...)
x.__rdivmod__(y) <==> divmod(y, x)
__reduce__(...)
__rfloordiv__(...)
x.__rfloordiv__(y) <==> y//x
__rlshift__(...)
x.__rlshift__(y) <==> y<<x
__rmod__(...)
x.__rmod__(y) <==> y%x
__rmul__(...)
x.__rmul__(y) <==> y*x
__ror__(...)
x.__ror__(y) <==> y|x
__rpow__(...)
y.__rpow__(x[, z]) <==> pow(x, y[, z])
__rrshift__(...)
x.__rrshift__(y) <==> y>>x
__rshift__(...)
x.__rshift__(y) <==> x>>y
__rsub__(...)
x.__rsub__(y) <==> y-x
__rtruediv__(...)
x.__rtruediv__(y) <==> y/x
__rxor__(...)
x.__rxor__(y) <==> y^x
__setstate__(...)
__sub__(...)
x.__sub__(y) <==> x-y
__truediv__(...)
x.__truediv__(y) <==> x/y
__xor__(...)
x.__xor__(y) <==> x^y
all(...)
any(...)
argmax(...)
argmin(...)
argsort(...)
astype(...)
byteswap(...)
choose(...)
clip(...)
compress(...)
conj(...)
conjugate(...)
copy(...)
cumprod(...)
cumsum(...)
diagonal(...)
dump(...)
dumps(...)
fill(...)
flatten(...)
getfield(...)
item(...)
itemset(...)
max(...)
mean(...)
min(...)
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:
 
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
 
Parameters
----------
new_order : string, 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(...)
prod(...)
ptp(...)
put(...)
ravel(...)
repeat(...)
reshape(...)
resize(...)
round(...)
searchsorted(...)
setfield(...)
setflags(...)
sort(...)
squeeze(...)
std(...)
sum(...)
swapaxes(...)
take(...)
tofile(...)
tolist(...)
tostring(...)
trace(...)
transpose(...)
var(...)
view(...)

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

Methods inherited from complex:
__coerce__(...)
x.__coerce__(y) <==> coerce(x, y)
__getattribute__(...)
x.__getattribute__('name') <==> x.name
__getnewargs__(...)
__hash__(...)
x.__hash__() <==> hash(x)

 
cfloat = class complex128(complexfloating, complex)
    Composed of two 64 bit floats
 
 
Method resolution order:
complex128
complexfloating
inexact
number
generic
complex
object

Methods defined here:
__eq__(...)
x.__eq__(y) <==> x==y
__ge__(...)
x.__ge__(y) <==> x>=y
__gt__(...)
x.__gt__(y) <==> x>y
__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 at 0x7f8ebc33bec0>
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
__getitem__(...)
x.__getitem__(y) <==> x[y]
__hex__(...)
x.__hex__() <==> hex(x)
__int__(...)
x.__int__() <==> int(x)
__invert__(...)
x.__invert__() <==> ~x
__long__(...)
x.__long__() <==> long(x)
__lshift__(...)
x.__lshift__(y) <==> x<<y
__mod__(...)
x.__mod__(y) <==> x%y
__mul__(...)
x.__mul__(y) <==> x*y
__neg__(...)
x.__neg__() <==> -x
__nonzero__(...)
x.__nonzero__() <==> x != 0
__oct__(...)
x.__oct__() <==> oct(x)
__or__(...)
x.__or__(y) <==> x|y
__pos__(...)
x.__pos__() <==> +x
__pow__(...)
x.__pow__(y[, z]) <==> pow(x, y[, z])
__radd__(...)
x.__radd__(y) <==> y+x
__rand__(...)
x.__rand__(y) <==> y&x
__rdiv__(...)
x.__rdiv__(y) <==> y/x
__rdivmod__(...)
x.__rdivmod__(y) <==> divmod(y, x)
__reduce__(...)
__rfloordiv__(...)
x.__rfloordiv__(y) <==> y//x
__rlshift__(...)
x.__rlshift__(y) <==> y<<x
__rmod__(...)
x.__rmod__(y) <==> y%x
__rmul__(...)
x.__rmul__(y) <==> y*x
__ror__(...)
x.__ror__(y) <==> y|x
__rpow__(...)
y.__rpow__(x[, z]) <==> pow(x, y[, z])
__rrshift__(...)
x.__rrshift__(y) <==> y>>x
__rshift__(...)
x.__rshift__(y) <==> x>>y
__rsub__(...)
x.__rsub__(y) <==> y-x
__rtruediv__(...)
x.__rtruediv__(y) <==> y/x
__rxor__(...)
x.__rxor__(y) <==> y^x
__setstate__(...)
__sub__(...)
x.__sub__(y) <==> x-y
__truediv__(...)
x.__truediv__(y) <==> x/y
__xor__(...)
x.__xor__(y) <==> x^y
all(...)
any(...)
argmax(...)
argmin(...)
argsort(...)
astype(...)
byteswap(...)
choose(...)
clip(...)
compress(...)
conj(...)
conjugate(...)
copy(...)
cumprod(...)
cumsum(...)
diagonal(...)
dump(...)
dumps(...)
fill(...)
flatten(...)
getfield(...)
item(...)
itemset(...)
max(...)
mean(...)
min(...)
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:
 
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
 
Parameters
----------
new_order : string, 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(...)
prod(...)
ptp(...)
put(...)
ravel(...)
repeat(...)
reshape(...)
resize(...)
round(...)
searchsorted(...)
setfield(...)
setflags(...)
sort(...)
squeeze(...)
std(...)
sum(...)
swapaxes(...)
take(...)
tofile(...)
tolist(...)
tostring(...)
trace(...)
transpose(...)
var(...)
view(...)

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

Methods inherited from complex:
__coerce__(...)
x.__coerce__(y) <==> coerce(x, y)
__getattribute__(...)
x.__getattribute__('name') <==> x.name
__getnewargs__(...)
__hash__(...)
x.__hash__() <==> hash(x)

 
class character(flexible)
    
Method resolution order:
character
flexible
generic
object

Methods inherited from generic:
__abs__(...)
x.__abs__() <==> abs(x)
__add__(...)
x.__add__(y) <==> x+y
__and__(...)
x.__and__(y) <==> x&y
__array__(...)
sc.__array__(|type) return 0-dim array
__array_wrap__(...)
sc.__array_wrap__(obj) return scalar from array
__copy__(...)
__deepcopy__(...)
__div__(...)
x.__div__(y) <==> x/y
__divmod__(...)
x.__divmod__(y) <==> divmod(x, y)
__eq__(...)
x.__eq__(y) <==> x==y
__float__(...)
x.__float__() <==> float(x)
__floordiv__(...)
x.__floordiv__(y) <==> x//y
__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__(...)
__str__(...)
x.__str__() <==> str(x)
__sub__(...)
x.__sub__(y) <==> x-y
__truediv__(...)
x.__truediv__(y) <==> x/y
__xor__(...)
x.__xor__(y) <==> x^y
all(...)
any(...)
argmax(...)
argmin(...)
argsort(...)
astype(...)
byteswap(...)
choose(...)
clip(...)
compress(...)
conj(...)
conjugate(...)
copy(...)
cumprod(...)
cumsum(...)
diagonal(...)
dump(...)
dumps(...)
fill(...)
flatten(...)
getfield(...)
item(...)
itemset(...)
max(...)
mean(...)
min(...)
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:
 
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
 
Parameters
----------
new_order : string, 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(...)
prod(...)
ptp(...)
put(...)
ravel(...)
repeat(...)
reshape(...)
resize(...)
round(...)
searchsorted(...)
setfield(...)
setflags(...)
sort(...)
squeeze(...)
std(...)
sum(...)
swapaxes(...)
take(...)
tofile(...)
tolist(...)
tostring(...)
trace(...)
transpose(...)
var(...)
view(...)

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

 
clongdouble = class complex256(complexfloating)
    Composed of two 128 bit floats
 
 
Method resolution order:
complex256
complexfloating
inexact
number
generic
object

Methods defined here:
__eq__(...)
x.__eq__(y) <==> x==y
__float__(...)
x.__float__() <==> float(x)
__ge__(...)
x.__ge__(y) <==> x>=y
__gt__(...)
x.__gt__(y) <==> x>y
__hash__(...)
x.__hash__() <==> hash(x)
__hex__(...)
x.__hex__() <==> hex(x)
__int__(...)
x.__int__() <==> int(x)
__le__(...)
x.__le__(y) <==> x<=y
__long__(...)
x.__long__() <==> long(x)
__lt__(...)
x.__lt__(y) <==> x<y
__ne__(...)
x.__ne__(y) <==> x!=y
__oct__(...)
x.__oct__() <==> oct(x)
__repr__(...)
x.__repr__() <==> repr(x)
__str__(...)
x.__str__() <==> str(x)

Data and other attributes defined here:
__new__ = <built-in method __new__ of type object at 0x7f8ebc33c060>
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)
__floordiv__(...)
x.__floordiv__(y) <==> x//y
__getitem__(...)
x.__getitem__(y) <==> x[y]
__invert__(...)
x.__invert__() <==> ~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
__or__(...)
x.__or__(y) <==> x|y
__pos__(...)
x.__pos__() <==> +x
__pow__(...)
x.__pow__(y[, z]) <==> pow(x, y[, z])
__radd__(...)
x.__radd__(y) <==> y+x
__rand__(...)
x.__rand__(y) <==> y&x
__rdiv__(...)
x.__rdiv__(y) <==> y/x
__rdivmod__(...)
x.__rdivmod__(y) <==> divmod(y, x)
__reduce__(...)
__rfloordiv__(...)
x.__rfloordiv__(y) <==> y//x
__rlshift__(...)
x.__rlshift__(y) <==> y<<x
__rmod__(...)
x.__rmod__(y) <==> y%x
__rmul__(...)
x.__rmul__(y) <==> y*x
__ror__(...)
x.__ror__(y) <==> y|x
__rpow__(...)
y.__rpow__(x[, z]) <==> pow(x, y[, z])
__rrshift__(...)
x.__rrshift__(y) <==> y>>x
__rshift__(...)
x.__rshift__(y) <==> x>>y
__rsub__(...)
x.__rsub__(y) <==> y-x
__rtruediv__(...)
x.__rtruediv__(y) <==> y/x
__rxor__(...)
x.__rxor__(y) <==> y^x
__setstate__(...)
__sub__(...)
x.__sub__(y) <==> x-y
__truediv__(...)
x.__truediv__(y) <==> x/y
__xor__(...)
x.__xor__(y) <==> x^y
all(...)
any(...)
argmax(...)
argmin(...)
argsort(...)
astype(...)
byteswap(...)
choose(...)
clip(...)
compress(...)
conj(...)
conjugate(...)
copy(...)
cumprod(...)
cumsum(...)
diagonal(...)
dump(...)
dumps(...)
fill(...)
flatten(...)
getfield(...)
item(...)
itemset(...)
max(...)
mean(...)
min(...)
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:
 
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
 
Parameters
----------
new_order : string, 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(...)
prod(...)
ptp(...)
put(...)
ravel(...)
repeat(...)
reshape(...)
resize(...)
round(...)
searchsorted(...)
setfield(...)
setflags(...)
sort(...)
squeeze(...)
std(...)
sum(...)
swapaxes(...)
take(...)
tofile(...)
tolist(...)
tostring(...)
trace(...)
transpose(...)
var(...)
view(...)

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

 
clongfloat = class complex256(complexfloating)
    Composed of two 128 bit floats
 
 
Method resolution order:
complex256
complexfloating
inexact
number
generic
object

Methods defined here:
__eq__(...)
x.__eq__(y) <==> x==y
__float__(...)
x.__float__() <==> float(x)
__ge__(...)
x.__ge__(y) <==> x>=y
__gt__(...)
x.__gt__(y) <==> x>y
__hash__(...)
x.__hash__() <==> hash(x)
__hex__(...)
x.__hex__() <==> hex(x)
__int__(...)
x.__int__() <==> int(x)
__le__(...)
x.__le__(y) <==> x<=y
__long__(...)
x.__long__() <==> long(x)
__lt__(...)
x.__lt__(y) <==> x<y
__ne__(...)
x.__ne__(y) <==> x!=y
__oct__(...)
x.__oct__() <==> oct(x)
__repr__(...)
x.__repr__() <==> repr(x)
__str__(...)
x.__str__() <==> str(x)

Data and other attributes defined here:
__new__ = <built-in method __new__ of type object at 0x7f8ebc33c060>
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)
__floordiv__(...)
x.__floordiv__(y) <==> x//y
__getitem__(...)
x.__getitem__(y) <==> x[y]
__invert__(...)
x.__invert__() <==> ~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
__or__(...)
x.__or__(y) <==> x|y
__pos__(...)
x.__pos__() <==> +x
__pow__(...)
x.__pow__(y[, z]) <==> pow(x, y[, z])
__radd__(...)
x.__radd__(y) <==> y+x
__rand__(...)
x.__rand__(y) <==> y&x
__rdiv__(...)
x.__rdiv__(y) <==> y/x
__rdivmod__(...)
x.__rdivmod__(y) <==> divmod(y, x)
__reduce__(...)
__rfloordiv__(...)
x.__rfloordiv__(y) <==> y//x
__rlshift__(...)
x.__rlshift__(y) <==> y<<x
__rmod__(...)
x.__rmod__(y) <==> y%x
__rmul__(...)
x.__rmul__(y) <==> y*x
__ror__(...)
x.__ror__(y) <==> y|x
__rpow__(...)
y.__rpow__(x[, z]) <==> pow(x, y[, z])
__rrshift__(...)
x.__rrshift__(y) <==> y>>x
__rshift__(...)
x.__rshift__(y) <==> x>>y
__rsub__(...)
x.__rsub__(y) <==> y-x
__rtruediv__(...)
x.__rtruediv__(y) <==> y/x
__rxor__(...)
x.__rxor__(y) <==> y^x
__setstate__(...)
__sub__(...)
x.__sub__(y) <==> x-y
__truediv__(...)
x.__truediv__(y) <==> x/y
__xor__(...)
x.__xor__(y) <==> x^y
all(...)
any(...)
argmax(...)
argmin(...)
argsort(...)
astype(...)
byteswap(...)
choose(...)
clip(...)
compress(...)
conj(...)
conjugate(...)
copy(...)
cumprod(...)
cumsum(...)
diagonal(...)
dump(...)
dumps(...)
fill(...)
flatten(...)
getfield(...)
item(...)
itemset(...)
max(...)
mean(...)
min(...)
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:
 
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
 
Parameters
----------
new_order : string, 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(...)
prod(...)
ptp(...)
put(...)
ravel(...)
repeat(...)
reshape(...)
resize(...)
round(...)
searchsorted(...)
setfield(...)
setflags(...)
sort(...)
squeeze(...)
std(...)
sum(...)
swapaxes(...)
take(...)
tofile(...)
tolist(...)
tostring(...)
trace(...)
transpose(...)
var(...)
view(...)

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 complex128(complexfloating, complex)
    Composed of two 64 bit floats
 
 
Method resolution order:
complex128
complexfloating
inexact
number
generic
complex
object

Methods defined here:
__eq__(...)
x.__eq__(y) <==> x==y
__ge__(...)
x.__ge__(y) <==> x>=y
__gt__(...)
x.__gt__(y) <==> x>y
__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 at 0x7f8ebc33bec0>
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
__getitem__(...)
x.__getitem__(y) <==> x[y]
__hex__(...)
x.__hex__() <==> hex(x)
__int__(...)
x.__int__() <==> int(x)
__invert__(...)
x.__invert__() <==> ~x
__long__(...)
x.__long__() <==> long(x)
__lshift__(...)
x.__lshift__(y) <==> x<<y
__mod__(...)
x.__mod__(y) <==> x%y
__mul__(...)
x.__mul__(y) <==> x*y
__neg__(...)
x.__neg__() <==> -x
__nonzero__(...)
x.__nonzero__() <==> x != 0
__oct__(...)
x.__oct__() <==> oct(x)
__or__(...)
x.__or__(y) <==> x|y
__pos__(...)
x.__pos__() <==> +x
__pow__(...)
x.__pow__(y[, z]) <==> pow(x, y[, z])
__radd__(...)
x.__radd__(y) <==> y+x
__rand__(...)
x.__rand__(y) <==> y&x
__rdiv__(...)
x.__rdiv__(y) <==> y/x
__rdivmod__(...)
x.__rdivmod__(y) <==> divmod(y, x)
__reduce__(...)
__rfloordiv__(...)
x.__rfloordiv__(y) <==> y//x
__rlshift__(...)
x.__rlshift__(y) <==> y<<x
__rmod__(...)
x.__rmod__(y) <==> y%x
__rmul__(...)
x.__rmul__(y) <==> y*x
__ror__(...)
x.__ror__(y) <==> y|x
__rpow__(...)
y.__rpow__(x[, z]) <==> pow(x, y[, z])
__rrshift__(...)
x.__rrshift__(y) <==> y>>x
__rshift__(...)
x.__rshift__(y) <==> x>>y
__rsub__(...)
x.__rsub__(y) <==> y-x
__rtruediv__(...)
x.__rtruediv__(y) <==> y/x
__rxor__(...)
x.__rxor__(y) <==> y^x
__setstate__(...)
__sub__(...)
x.__sub__(y) <==> x-y
__truediv__(...)
x.__truediv__(y) <==> x/y
__xor__(...)
x.__xor__(y) <==> x^y
all(...)
any(...)
argmax(...)
argmin(...)
argsort(...)
astype(...)
byteswap(...)
choose(...)
clip(...)
compress(...)
conj(...)
conjugate(...)
copy(...)
cumprod(...)
cumsum(...)
diagonal(...)
dump(...)
dumps(...)
fill(...)
flatten(...)
getfield(...)
item(...)
itemset(...)
max(...)
mean(...)
min(...)
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:
 
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
 
Parameters
----------
new_order : string, 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(...)
prod(...)
ptp(...)
put(...)
ravel(...)
repeat(...)
reshape(...)
resize(...)
round(...)
searchsorted(...)
setfield(...)
setflags(...)
sort(...)
squeeze(...)
std(...)
sum(...)
swapaxes(...)
take(...)
tofile(...)
tolist(...)
tostring(...)
trace(...)
transpose(...)
var(...)
view(...)

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

Methods inherited from complex:
__coerce__(...)
x.__coerce__(y) <==> coerce(x, y)
__getattribute__(...)
x.__getattribute__('name') <==> x.name
__getnewargs__(...)
__hash__(...)
x.__hash__() <==> hash(x)

 
class complex256(complexfloating)
    Composed of two 128 bit floats
 
 
Method resolution order:
complex256
complexfloating
inexact
number
generic
object

Methods defined here:
__eq__(...)
x.__eq__(y) <==> x==y
__float__(...)
x.__float__() <==> float(x)
__ge__(...)
x.__ge__(y) <==> x>=y
__gt__(...)
x.__gt__(y) <==> x>y
__hash__(...)
x.__hash__() <==> hash(x)
__hex__(...)
x.__hex__() <==> hex(x)
__int__(...)
x.__int__() <==> int(x)
__le__(...)
x.__le__(y) <==> x<=y
__long__(...)
x.__long__() <==> long(x)
__lt__(...)
x.__lt__(y) <==> x<y
__ne__(...)
x.__ne__(y) <==> x!=y
__oct__(...)
x.__oct__() <==> oct(x)
__repr__(...)
x.__repr__() <==> repr(x)
__str__(...)
x.__str__() <==> str(x)

Data and other attributes defined here:
__new__ = <built-in method __new__ of type object at 0x7f8ebc33c060>
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)
__floordiv__(...)
x.__floordiv__(y) <==> x//y
__getitem__(...)
x.__getitem__(y) <==> x[y]
__invert__(...)
x.__invert__() <==> ~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
__or__(...)
x.__or__(y) <==> x|y
__pos__(...)
x.__pos__() <==> +x
__pow__(...)
x.__pow__(y[, z]) <==> pow(x, y[, z])
__radd__(...)
x.__radd__(y) <==> y+x
__rand__(...)
x.__rand__(y) <==> y&x
__rdiv__(...)
x.__rdiv__(y) <==> y/x
__rdivmod__(...)
x.__rdivmod__(y) <==> divmod(y, x)
__reduce__(...)
__rfloordiv__(...)
x.__rfloordiv__(y) <==> y//x
__rlshift__(...)
x.__rlshift__(y) <==> y<<x
__rmod__(...)
x.__rmod__(y) <==> y%x
__rmul__(...)
x.__rmul__(y) <==> y*x
__ror__(...)
x.__ror__(y) <==> y|x
__rpow__(...)
y.__rpow__(x[, z]) <==> pow(x, y[, z])
__rrshift__(...)
x.__rrshift__(y) <==> y>>x
__rshift__(...)
x.__rshift__(y) <==> x>>y
__rsub__(...)
x.__rsub__(y) <==> y-x
__rtruediv__(...)
x.__rtruediv__(y) <==> y/x
__rxor__(...)
x.__rxor__(y) <==> y^x
__setstate__(...)
__sub__(...)
x.__sub__(y) <==> x-y
__truediv__(...)
x.__truediv__(y) <==> x/y
__xor__(...)
x.__xor__(y) <==> x^y
all(...)
any(...)
argmax(...)
argmin(...)
argsort(...)
astype(...)
byteswap(...)
choose(...)
clip(...)
compress(...)
conj(...)
conjugate(...)
copy(...)
cumprod(...)
cumsum(...)
diagonal(...)
dump(...)
dumps(...)
fill(...)
flatten(...)
getfield(...)
item(...)
itemset(...)
max(...)
mean(...)
min(...)
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:
 
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
 
Parameters
----------
new_order : string, 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(...)
prod(...)
ptp(...)
put(...)
ravel(...)
repeat(...)
reshape(...)
resize(...)
round(...)
searchsorted(...)
setfield(...)
setflags(...)
sort(...)
squeeze(...)
std(...)
sum(...)
swapaxes(...)
take(...)
tofile(...)
tolist(...)
tostring(...)
trace(...)
transpose(...)
var(...)
view(...)

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 complex64(complexfloating)
    Composed of two 32 bit floats
 
 
Method resolution order:
complex64
complexfloating
inexact
number
generic
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 at 0x7f8ebc33bd20>
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
__getitem__(...)
x.__getitem__(y) <==> x[y]
__hex__(...)
x.__hex__() <==> hex(x)
__int__(...)
x.__int__() <==> int(x)
__invert__(...)
x.__invert__() <==> ~x
__long__(...)
x.__long__() <==> long(x)
__lshift__(...)
x.__lshift__(y) <==> x<<y
__mod__(...)
x.__mod__(y) <==> x%y
__mul__(...)
x.__mul__(y) <==> x*y
__neg__(...)
x.__neg__() <==> -x
__nonzero__(...)
x.__nonzero__() <==> x != 0
__oct__(...)
x.__oct__() <==> oct(x)
__or__(...)
x.__or__(y) <==> x|y
__pos__(...)
x.__pos__() <==> +x
__pow__(...)
x.__pow__(y[, z]) <==> pow(x, y[, z])
__radd__(...)
x.__radd__(y) <==> y+x
__rand__(...)
x.__rand__(y) <==> y&x
__rdiv__(...)
x.__rdiv__(y) <==> y/x
__rdivmod__(...)
x.__rdivmod__(y) <==> divmod(y, x)
__reduce__(...)
__rfloordiv__(...)
x.__rfloordiv__(y) <==> y//x
__rlshift__(...)
x.__rlshift__(y) <==> y<<x
__rmod__(...)
x.__rmod__(y) <==> y%x
__rmul__(...)
x.__rmul__(y) <==> y*x
__ror__(...)
x.__ror__(y) <==> y|x
__rpow__(...)
y.__rpow__(x[, z]) <==> pow(x, y[, z])
__rrshift__(...)
x.__rrshift__(y) <==> y>>x
__rshift__(...)
x.__rshift__(y) <==> x>>y
__rsub__(...)
x.__rsub__(y) <==> y-x
__rtruediv__(...)
x.__rtruediv__(y) <==> y/x
__rxor__(...)
x.__rxor__(y) <==> y^x
__setstate__(...)
__sub__(...)
x.__sub__(y) <==> x-y
__truediv__(...)
x.__truediv__(y) <==> x/y
__xor__(...)
x.__xor__(y) <==> x^y
all(...)
any(...)
argmax(...)
argmin(...)
argsort(...)
astype(...)
byteswap(...)
choose(...)
clip(...)
compress(...)
conj(...)
conjugate(...)
copy(...)
cumprod(...)
cumsum(...)
diagonal(...)
dump(...)
dumps(...)
fill(...)
flatten(...)
getfield(...)
item(...)
itemset(...)
max(...)
mean(...)
min(...)
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:
 
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
 
Parameters
----------
new_order : string, 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(...)
prod(...)
ptp(...)
put(...)
ravel(...)
repeat(...)
reshape(...)
resize(...)
round(...)
searchsorted(...)
setfield(...)
setflags(...)
sort(...)
squeeze(...)
std(...)
sum(...)
swapaxes(...)
take(...)
tofile(...)
tolist(...)
tostring(...)
trace(...)
transpose(...)
var(...)
view(...)

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

 
complex_ = class complex128(complexfloating, complex)
    Composed of two 64 bit floats
 
 
Method resolution order:
complex128
complexfloating
inexact
number
generic
complex
object

Methods defined here:
__eq__(...)
x.__eq__(y) <==> x==y
__ge__(...)
x.__ge__(y) <==> x>=y
__gt__(...)
x.__gt__(y) <==> x>y
__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 at 0x7f8ebc33bec0>
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
__getitem__(...)
x.__getitem__(y) <==> x[y]
__hex__(...)
x.__hex__() <==> hex(x)
__int__(...)
x.__int__() <==> int(x)
__invert__(...)
x.__invert__() <==> ~x
__long__(...)
x.__long__() <==> long(x)
__lshift__(...)
x.__lshift__(y) <==> x<<y
__mod__(...)
x.__mod__(y) <==> x%y
__mul__(...)
x.__mul__(y) <==> x*y
__neg__(...)
x.__neg__() <==> -x
__nonzero__(...)
x.__nonzero__() <==> x != 0
__oct__(...)
x.__oct__() <==> oct(x)
__or__(...)
x.__or__(y) <==> x|y
__pos__(...)
x.__pos__() <==> +x
__pow__(...)
x.__pow__(y[, z]) <==> pow(x, y[, z])
__radd__(...)
x.__radd__(y) <==> y+x
__rand__(...)
x.__rand__(y) <==> y&x
__rdiv__(...)
x.__rdiv__(y) <==> y/x
__rdivmod__(...)
x.__rdivmod__(y) <==> divmod(y, x)
__reduce__(...)
__rfloordiv__(...)
x.__rfloordiv__(y) <==> y//x
__rlshift__(...)
x.__rlshift__(y) <==> y<<x
__rmod__(...)
x.__rmod__(y) <==> y%x
__rmul__(...)
x.__rmul__(y) <==> y*x
__ror__(...)
x.__ror__(y) <==> y|x
__rpow__(...)
y.__rpow__(x[, z]) <==> pow(x, y[, z])
__rrshift__(...)
x.__rrshift__(y) <==> y>>x
__rshift__(...)
x.__rshift__(y) <==> x>>y
__rsub__(...)
x.__rsub__(y) <==> y-x
__rtruediv__(...)
x.__rtruediv__(y) <==> y/x
__rxor__(...)
x.__rxor__(y) <==> y^x
__setstate__(...)
__sub__(...)
x.__sub__(y) <==> x-y
__truediv__(...)
x.__truediv__(y) <==> x/y
__xor__(...)
x.__xor__(y) <==> x^y
all(...)
any(...)
argmax(...)
argmin(...)
argsort(...)
astype(...)
byteswap(...)
choose(...)
clip(...)
compress(...)
conj(...)
conjugate(...)
copy(...)
cumprod(...)
cumsum(...)
diagonal(...)
dump(...)
dumps(...)
fill(...)
flatten(...)
getfield(...)
item(...)
itemset(...)
max(...)
mean(...)
min(...)
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:
 
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
 
Parameters
----------
new_order : string, 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(...)
prod(...)
ptp(...)
put(...)
ravel(...)
repeat(...)
reshape(...)
resize(...)
round(...)
searchsorted(...)
setfield(...)
setflags(...)
sort(...)
squeeze(...)
std(...)
sum(...)
swapaxes(...)
take(...)
tofile(...)
tolist(...)
tostring(...)
trace(...)
transpose(...)
var(...)
view(...)

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

Methods inherited from complex:
__coerce__(...)
x.__coerce__(y) <==> coerce(x, y)
__getattribute__(...)
x.__getattribute__('name') <==> x.name
__getnewargs__(...)
__hash__(...)
x.__hash__() <==> hash(x)

 
class complexfloating(inexact)
    
Method resolution order:
complexfloating
inexact
number
generic
object

Methods inherited from generic:
__abs__(...)
x.__abs__() <==> abs(x)
__add__(...)
x.__add__(y) <==> x+y
__and__(...)
x.__and__(y) <==> x&y
__array__(...)
sc.__array__(|type) return 0-dim array
__array_wrap__(...)
sc.__array_wrap__(obj) return scalar from array
__copy__(...)
__deepcopy__(...)
__div__(...)
x.__div__(y) <==> x/y
__divmod__(...)
x.__divmod__(y) <==> divmod(x, y)
__eq__(...)
x.__eq__(y) <==> x==y
__float__(...)
x.__float__() <==> float(x)
__floordiv__(...)
x.__floordiv__(y) <==> x//y
__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__(...)
__str__(...)
x.__str__() <==> str(x)
__sub__(...)
x.__sub__(y) <==> x-y
__truediv__(...)
x.__truediv__(y) <==> x/y
__xor__(...)
x.__xor__(y) <==> x^y
all(...)
any(...)
argmax(...)
argmin(...)
argsort(...)
astype(...)
byteswap(...)
choose(...)
clip(...)
compress(...)
conj(...)
conjugate(...)
copy(...)
cumprod(...)
cumsum(...)
diagonal(...)
dump(...)
dumps(...)
fill(...)
flatten(...)
getfield(...)
item(...)
itemset(...)
max(...)
mean(...)
min(...)
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:
 
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
 
Parameters
----------
new_order : string, 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(...)
prod(...)
ptp(...)
put(...)
ravel(...)
repeat(...)
reshape(...)
resize(...)
round(...)
searchsorted(...)
setfield(...)
setflags(...)
sort(...)
squeeze(...)
std(...)
sum(...)
swapaxes(...)
take(...)
tofile(...)
tolist(...)
tostring(...)
trace(...)
transpose(...)
var(...)
view(...)

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

 
csingle = class complex64(complexfloating)
    Composed of two 32 bit floats
 
 
Method resolution order:
complex64
complexfloating
inexact
number
generic
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 at 0x7f8ebc33bd20>
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
__getitem__(...)
x.__getitem__(y) <==> x[y]
__hex__(...)
x.__hex__() <==> hex(x)
__int__(...)
x.__int__() <==> int(x)
__invert__(...)
x.__invert__() <==> ~x
__long__(...)
x.__long__() <==> long(x)
__lshift__(...)
x.__lshift__(y) <==> x<<y
__mod__(...)
x.__mod__(y) <==> x%y
__mul__(...)
x.__mul__(y) <==> x*y
__neg__(...)
x.__neg__() <==> -x
__nonzero__(...)
x.__nonzero__() <==> x != 0
__oct__(...)
x.__oct__() <==> oct(x)
__or__(...)
x.__or__(y) <==> x|y
__pos__(...)
x.__pos__() <==> +x
__pow__(...)
x.__pow__(y[, z]) <==> pow(x, y[, z])
__radd__(...)
x.__radd__(y) <==> y+x
__rand__(...)
x.__rand__(y) <==> y&x
__rdiv__(...)
x.__rdiv__(y) <==> y/x
__rdivmod__(...)
x.__rdivmod__(y) <==> divmod(y, x)
__reduce__(...)
__rfloordiv__(...)
x.__rfloordiv__(y) <==> y//x
__rlshift__(...)
x.__rlshift__(y) <==> y<<x
__rmod__(...)
x.__rmod__(y) <==> y%x
__rmul__(...)
x.__rmul__(y) <==> y*x
__ror__(...)
x.__ror__(y) <==> y|x
__rpow__(...)
y.__rpow__(x[, z]) <==> pow(x, y[, z])
__rrshift__(...)
x.__rrshift__(y) <==> y>>x
__rshift__(...)
x.__rshift__(y) <==> x>>y
__rsub__(...)
x.__rsub__(y) <==> y-x
__rtruediv__(...)
x.__rtruediv__(y) <==> y/x
__rxor__(...)
x.__rxor__(y) <==> y^x
__setstate__(...)
__sub__(...)
x.__sub__(y) <==> x-y
__truediv__(...)
x.__truediv__(y) <==> x/y
__xor__(...)
x.__xor__(y) <==> x^y
all(...)
any(...)
argmax(...)
argmin(...)
argsort(...)
astype(...)
byteswap(...)
choose(...)
clip(...)
compress(...)
conj(...)
conjugate(...)
copy(...)
cumprod(...)
cumsum(...)
diagonal(...)
dump(...)
dumps(...)
fill(...)
flatten(...)
getfield(...)
item(...)
itemset(...)
max(...)
mean(...)
min(...)
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:
 
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
 
Parameters
----------
new_order : string, 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(...)
prod(...)
ptp(...)
put(...)
ravel(...)
repeat(...)
reshape(...)
resize(...)
round(...)
searchsorted(...)
setfield(...)
setflags(...)
sort(...)
squeeze(...)
std(...)
sum(...)
swapaxes(...)
take(...)
tofile(...)
tolist(...)
tostring(...)
trace(...)
transpose(...)
var(...)
view(...)

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

 
double = class float64(floating, float)
    64-bit floating-point number. Character code ``d``.
 
 
Method resolution order:
float64
floating
inexact
number
generic
float
object

Methods defined here:
__eq__(...)
x.__eq__(y) <==> x==y
__ge__(...)
x.__ge__(y) <==> x>=y
__gt__(...)
x.__gt__(y) <==> x>y
__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 at 0x7f8ebc33b9e0>
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
__getitem__(...)
x.__getitem__(y) <==> x[y]
__hex__(...)
x.__hex__() <==> hex(x)
__int__(...)
x.__int__() <==> int(x)
__invert__(...)
x.__invert__() <==> ~x
__long__(...)
x.__long__() <==> long(x)
__lshift__(...)
x.__lshift__(y) <==> x<<y
__mod__(...)
x.__mod__(y) <==> x%y
__mul__(...)
x.__mul__(y) <==> x*y
__neg__(...)
x.__neg__() <==> -x
__nonzero__(...)
x.__nonzero__() <==> x != 0
__oct__(...)
x.__oct__() <==> oct(x)
__or__(...)
x.__or__(y) <==> x|y
__pos__(...)
x.__pos__() <==> +x
__pow__(...)
x.__pow__(y[, z]) <==> pow(x, y[, z])
__radd__(...)
x.__radd__(y) <==> y+x
__rand__(...)
x.__rand__(y) <==> y&x
__rdiv__(...)
x.__rdiv__(y) <==> y/x
__rdivmod__(...)
x.__rdivmod__(y) <==> divmod(y, x)
__reduce__(...)
__rfloordiv__(...)
x.__rfloordiv__(y) <==> y//x
__rlshift__(...)
x.__rlshift__(y) <==> y<<x
__rmod__(...)
x.__rmod__(y) <==> y%x
__rmul__(...)
x.__rmul__(y) <==> y*x
__ror__(...)
x.__ror__(y) <==> y|x
__rpow__(...)
y.__rpow__(x[, z]) <==> pow(x, y[, z])
__rrshift__(...)
x.__rrshift__(y) <==> y>>x
__rshift__(...)
x.__rshift__(y) <==> x>>y
__rsub__(...)
x.__rsub__(y) <==> y-x
__rtruediv__(...)
x.__rtruediv__(y) <==> y/x
__rxor__(...)
x.__rxor__(y) <==> y^x
__setstate__(...)
__sub__(...)
x.__sub__(y) <==> x-y
__truediv__(...)
x.__truediv__(y) <==> x/y
__xor__(...)
x.__xor__(y) <==> x^y
all(...)
any(...)
argmax(...)
argmin(...)
argsort(...)
astype(...)
byteswap(...)
choose(...)
clip(...)
compress(...)
conj(...)
conjugate(...)
copy(...)
cumprod(...)
cumsum(...)
diagonal(...)
dump(...)
dumps(...)
fill(...)
flatten(...)
getfield(...)
item(...)
itemset(...)
max(...)
mean(...)
min(...)
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:
 
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
 
Parameters
----------
new_order : string, 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(...)
prod(...)
ptp(...)
put(...)
ravel(...)
repeat(...)
reshape(...)
resize(...)
round(...)
searchsorted(...)
setfield(...)
setflags(...)
sort(...)
squeeze(...)
std(...)
sum(...)
swapaxes(...)
take(...)
tofile(...)
tolist(...)
tostring(...)
trace(...)
transpose(...)
var(...)
view(...)

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

Methods inherited from float:
__coerce__(...)
x.__coerce__(y) <==> coerce(x, y)
__format__(...)
float.__format__(format_spec) -> string
 
Formats the float according to format_spec.
__getattribute__(...)
x.__getattribute__('name') <==> x.name
__getnewargs__(...)
__hash__(...)
x.__hash__() <==> hash(x)
__trunc__(...)
Returns the Integral closest to x between 0 and x.
as_integer_ratio(...)
float.as_integer_ratio() -> (intint)
 
Returns a pair of integers, whose ratio is exactly equal to the original
float and with a positive denominator.
Raises OverflowError on infinities and a ValueError on NaNs.
 
>>> (10.0).as_integer_ratio()
(10, 1)
>>> (0.0).as_integer_ratio()
(0, 1)
>>> (-.25).as_integer_ratio()
(-1, 4)
hex(...)
float.hex() -> string
 
Return a hexadecimal representation of a floating-point number.
>>> (-0.1).hex()
'-0x1.999999999999ap-4'
>>> 3.14159.hex()
'0x1.921f9f01b866ep+1'
is_integer(...)
Returns True if the float is an integer.

Data and other attributes inherited from float:
__getformat__ = <built-in method __getformat__ of type object at 0x7f8ebc33b9e0>
float.__getformat__(typestr) -> string
 
You probably don't want to use this function.  It exists mainly to be
used in Python's test suite.
 
typestr must be 'double' or 'float'.  This function returns whichever of
'unknown', 'IEEE, big-endian' or 'IEEE, little-endian' best describes the
format of floating point numbers used by the C type named by typestr.
__setformat__ = <built-in method __setformat__ of type object at 0x7f8ebc33b9e0>
float.__setformat__(typestr, fmt) -> None
 
You probably don't want to use this function.  It exists mainly to be
used in Python's test suite.
 
typestr must be 'double' or 'float'.  fmt must be one of 'unknown',
'IEEE, big-endian' or 'IEEE, little-endian', and in addition can only be
one of the latter two if it appears to match the underlying C reality.
 
Overrides the automatic determination of C-level floating point type.
This affects how floats are converted to and from binary strings.
fromhex = <built-in method fromhex of type object at 0x7f8ebc33b9e0>
float.fromhex(string) -> float
 
Create a floating-point number from a hexadecimal string.
>>> float.fromhex('0x1.ffffp10')
2047.984375
>>> float.fromhex('-0x1p-1074')
-4.9406564584124654e-324

 
class dtype(object)
    dtype(obj, align=False, copy=False)
 
Create a data type object.
 
A numpy array is homogeneous, and contains elements described by a
dtype object. A dtype object can be constructed from different
combinations of fundamental numeric types.
 
Parameters
----------
obj
    Object to be converted to a data type object.
align : bool, optional
    Add padding to the fields to match what a C compiler would output
    for a similar C-struct. Can be ``True`` only if `obj` is a dictionary
    or a comma-separated string.
copy : bool, optional
    Make a new copy of the data-type object. If ``False``, the result
    may just be a reference to a built-in data-type object.
 
Examples
--------
Using array-scalar type:
 
>>> np.dtype(np.int16)
dtype('int16')
 
Record, one field name 'f1', containing int16:
 
>>> np.dtype([('f1', np.int16)])
dtype([('f1', '<i2')])
 
Record, one field named 'f1', in itself containing a record with one field:
 
>>> np.dtype([('f1', [('f1', np.int16)])])
dtype([('f1', [('f1', '<i2')])])
 
Record, two fields: the first field contains an unsigned int, the
second an int32:
 
>>> np.dtype([('f1', np.uint), ('f2', np.int32)])
dtype([('f1', '<u4'), ('f2', '<i4')])
 
Using array-protocol type strings:
 
>>> np.dtype([('a','f8'),('b','S10')])
dtype([('a', '<f8'), ('b', '|S10')])
 
Using comma-separated field formats.  The shape is (2,3):
 
>>> np.dtype("i4, (2,3)f8")
dtype([('f0', '<i4'), ('f1', '<f8', (2, 3))])
 
Using tuples.  ``int`` is a fixed type, 3 the field's shape.  ``void``
is a flexible type, here of size 10:
 
>>> np.dtype([('hello',(np.int,3)),('world',np.void,10)])
dtype([('hello', '<i4', 3), ('world', '|V10')])
 
Subdivide ``int16`` into 2 ``int8``'s, called x and y.  0 and 1 are
the offsets in bytes:
 
>>> np.dtype((np.int16, {'x':(np.int8,0), 'y':(np.int8,1)}))
dtype(('<i2', [('x', '|i1'), ('y', '|i1')]))
 
Using dictionaries.  Two fields named 'gender' and 'age':
 
>>> np.dtype({'names':['gender','age'], 'formats':['S1',np.uint8]})
dtype([('gender', '|S1'), ('age', '|u1')])
 
Offsets in bytes, here 0 and 25:
 
>>> np.dtype({'surname':('S25',0),'age':(np.uint8,25)})
dtype([('surname', '|S25'), ('age', '|u1')])
 
  Methods defined here:
__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
__mul__(...)
x.__mul__(n) <==> x*n
__ne__(...)
x.__ne__(y) <==> x!=y
__reduce__(...)
__repr__(...)
x.__repr__() <==> repr(x)
__rmul__(...)
x.__rmul__(n) <==> n*x
__setstate__(...)
__str__(...)
x.__str__() <==> str(x)
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.
 
Parameters
----------
new_order : string, optional
    Byte order to force; a value from the byte order
    specifications below.  The default value ('S') results in
    swapping the current byte order.
    `new_order` codes can be any of::
 
     * 'S' - swap dtype from current to opposite endian
     * {'<', 'L'} - little endian
     * {'>', 'B'} - big endian
     * {'=', 'N'} - native order
     * {'|', 'I'} - ignore (no change to byte order)
 
    The code does a case-insensitive check on the first letter of
    `new_order` for these alternatives.  For example, any of '>'
    or 'B' or 'b' or 'brian' are valid to specify big-endian.
 
Returns
-------
new_dtype : dtype
    New dtype object with the given change to the byte order.
 
Notes
-----
Changes are also made in all fields and sub-arrays of the data type.
 
Examples
--------
>>> import sys
>>> sys_is_le = sys.byteorder == 'little'
>>> native_code = sys_is_le and '<' or '>'
>>> swapped_code = sys_is_le and '>' or '<'
>>> native_dt = np.dtype(native_code+'i2')
>>> swapped_dt = np.dtype(swapped_code+'i2')
>>> native_dt.newbyteorder('S') == swapped_dt
True
>>> native_dt.newbyteorder() == swapped_dt
True
>>> native_dt == swapped_dt.newbyteorder('S')
True
>>> native_dt == swapped_dt.newbyteorder('=')
True
>>> native_dt == swapped_dt.newbyteorder('N')
True
>>> native_dt == native_dt.newbyteorder('|')
True
>>> np.dtype('<i2') == native_dt.newbyteorder('<')
True
>>> np.dtype('<i2') == native_dt.newbyteorder('L')
True
>>> np.dtype('>i2') == native_dt.newbyteorder('>')
True
>>> np.dtype('>i2') == native_dt.newbyteorder('B')
True

Data descriptors defined here:
alignment
The required alignment (bytes) of this data-type according to the compiler.
 
More information is available in the C-API section of the manual.
base
byteorder
A character indicating the byte-order of this data-type object.
 
One of:
 
===  ==============
'='  native
'<'  little-endian
'>'  big-endian
'|'  not applicable
===  ==============
 
All built-in data-type objects have byteorder either '=' or '|'.
 
Examples
--------
 
>>> dt = np.dtype('i2')
>>> dt.byteorder
'='
>>> # endian is not relevant for 8 bit numbers
>>> np.dtype('i1').byteorder
'|'
>>> # or ASCII strings
>>> np.dtype('S2').byteorder
'|'
>>> # Even if specific code is given, and it is native
>>> # '=' is the byteorder
>>> import sys
>>> sys_is_le = sys.byteorder == 'little'
>>> native_code = sys_is_le and '<' or '>'
>>> swapped_code = sys_is_le and '>' or '<'
>>> dt = np.dtype(native_code + 'i2')
>>> dt.byteorder
'='
>>> # Swapped code shows up as itself
>>> dt = np.dtype(swapped_code + 'i2')
>>> dt.byteorder == swapped_code
True
char
A unique character code for each of the 21 different built-in types.
descr
Array-interface compliant full description of the data-type.
 
The format is that required by the 'descr' key in the
`__array_interface__` attribute.
fields
Dictionary showing any named fields defined for this data type, or None.
 
The dictionary is indexed by keys that are the names of the fields.
Each entry in the dictionary is a tuple fully describing the field::
 
  (dtype, offset[, title])
 
If present, the optional title can be any object (if it is string
or unicode then it will also be a key in the fields dictionary,
otherwise it's meta-data). Notice also, that the first two elements
of the tuple can be passed directly as arguments to the `ndarray.getfield`
and `ndarray.setfield` methods.
 
See Also
--------
ndarray.getfield, ndarray.setfield
flags
Bit-flags describing how this data type is to be interpreted.
 
Bit-masks are in `numpy.core.multiarray` as the constants
`ITEM_HASOBJECT`, `LIST_PICKLE`, `ITEM_IS_POINTER`, `NEEDS_INIT`,
`NEEDS_PYAPI`, `USE_GETITEM`, `USE_SETITEM`. A full explanation
of these flags is in C-API documentation; they are largely useful
for user-defined data-types.
hasobject
Boolean indicating whether this dtype contains any reference-counted
objects in any fields or sub-dtypes.
 
Recall that what is actually in the ndarray memory representing
the Python object is the memory address of that object (a pointer).
Special handling may be required, and this attribute is useful for
distinguishing data types that may contain arbitrary Python objects
and data-types that won't.
isbuiltin
Integer indicating how this dtype relates to the built-in dtypes.
 
=  ========================================================================
0  if this is a structured array type, with fields
1  if this is a dtype compiled into numpy (such as ints, floats etc)
2  if the dtype is for a user-defined numpy type
   A user-defined type uses the numpy C-API machinery to extend
   numpy to handle a new array type.  See the Guide to Numpy for
   details.
=  ========================================================================
 
Examples
--------
>>> dt = np.dtype('i2')
>>> dt.isbuiltin
1
>>> dt = np.dtype('f8')
>>> dt.isbuiltin
1
>>> dt = np.dtype([('field1', 'f8')])
>>> dt.isbuiltin
0
isnative
Boolean indicating whether the byte order of this dtype is native
to the platform.
itemsize
The element size of this data-type object.
 
For 18 of the 21 types this number is fixed by the data-type.
For the flexible data-types, this number can be anything.
kind
A character code (one of 'biufcSUV') identifying the general kind of data.
name
A bit-width name for this data-type.
 
Un-sized flexible data-type objects do not have this attribute.
names
Ordered list of field names, or ``None`` if there are no fields.
 
The names are ordered according to increasing byte offset.
num
A unique number for each of the 21 different built-in types.
 
These are roughly ordered from least-to-most precision.
shape
Shape tuple of the sub-array if this data type describes a sub-array,
and ``()`` otherwise.
str
The array-protocol typestring of this data-type object.
subdtype
Tuple ``(item_dtype, shape)`` if this `dtype` describes a sub-array, and
None otherwise.
 
The *shape* is the fixed shape of the sub-array described by this
data type, and *item_dtype* the data type of the array.
 
If a field whose dtype object has this attribute is retrieved,
then the extra dimensions implied by *shape* are tacked on to
the end of the retrieved array.
type
The type object used to instantiate a scalar of this data-type.

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

 
class flatiter(object)
     Methods defined here:
__array__(...)
__array__(type=None) Get array from iterator
__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
__iter__(...)
x.__iter__() <==> iter(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
copy(...)
copy() Get a copy of the iterator as a 1-d array
next(...)
x.next() -> the next value, or raise StopIteration

Data descriptors defined here:
base
documentation needed
coords
An N-d tuple of current coordinates.
index
documentation needed

 
class flexible(generic)
    
Method resolution order:
flexible
generic
object

Methods inherited from generic:
__abs__(...)
x.__abs__() <==> abs(x)
__add__(...)
x.__add__(y) <==> x+y
__and__(...)
x.__and__(y) <==> x&y
__array__(...)
sc.__array__(|type) return 0-dim array
__array_wrap__(...)
sc.__array_wrap__(obj) return scalar from array
__copy__(...)
__deepcopy__(...)
__div__(...)
x.__div__(y) <==> x/y
__divmod__(...)
x.__divmod__(y) <==> divmod(x, y)
__eq__(...)
x.__eq__(y) <==> x==y
__float__(...)
x.__float__() <==> float(x)
__floordiv__(...)
x.__floordiv__(y) <==> x//y
__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__(...)
__str__(...)
x.__str__() <==> str(x)
__sub__(...)
x.__sub__(y) <==> x-y
__truediv__(...)
x.__truediv__(y) <==> x/y
__xor__(...)
x.__xor__(y) <==> x^y
all(...)
any(...)
argmax(...)
argmin(...)
argsort(...)
astype(...)
byteswap(...)
choose(...)
clip(...)
compress(...)
conj(...)
conjugate(...)
copy(...)
cumprod(...)
cumsum(...)
diagonal(...)
dump(...)
dumps(...)
fill(...)
flatten(...)
getfield(...)
item(...)
itemset(...)
max(...)
mean(...)
min(...)
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:
 
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
 
Parameters
----------
new_order : string, 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(...)
prod(...)
ptp(...)
put(...)
ravel(...)
repeat(...)
reshape(...)
resize(...)
round(...)
searchsorted(...)
setfield(...)
setflags(...)
sort(...)
squeeze(...)
std(...)
sum(...)
swapaxes(...)
take(...)
tofile(...)
tolist(...)
tostring(...)
trace(...)
transpose(...)
var(...)
view(...)

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 float128(floating)
    
Method resolution order:
float128
floating
inexact
number
generic
object

Methods defined here:
__eq__(...)
x.__eq__(y) <==> x==y
__float__(...)
x.__float__() <==> float(x)
__ge__(...)
x.__ge__(y) <==> x>=y
__gt__(...)
x.__gt__(y) <==> x>y
__hash__(...)
x.__hash__() <==> hash(x)
__hex__(...)
x.__hex__() <==> hex(x)
__int__(...)
x.__int__() <==> int(x)
__le__(...)
x.__le__(y) <==> x<=y
__long__(...)
x.__long__() <==> long(x)
__lt__(...)
x.__lt__(y) <==> x<y
__ne__(...)
x.__ne__(y) <==> x!=y
__oct__(...)
x.__oct__() <==> oct(x)
__repr__(...)
x.__repr__() <==> repr(x)
__str__(...)
x.__str__() <==> str(x)

Data and other attributes defined here:
__new__ = <built-in method __new__ of type object at 0x7f8ebc33bb80>
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)
__floordiv__(...)
x.__floordiv__(y) <==> x//y
__getitem__(...)
x.__getitem__(y) <==> x[y]
__invert__(...)
x.__invert__() <==> ~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
__or__(...)
x.__or__(y) <==> x|y
__pos__(...)
x.__pos__() <==> +x
__pow__(...)
x.__pow__(y[, z]) <==> pow(x, y[, z])
__radd__(...)
x.__radd__(y) <==> y+x
__rand__(...)
x.__rand__(y) <==> y&x
__rdiv__(...)
x.__rdiv__(y) <==> y/x
__rdivmod__(...)
x.__rdivmod__(y) <==> divmod(y, x)
__reduce__(...)
__rfloordiv__(...)
x.__rfloordiv__(y) <==> y//x
__rlshift__(...)
x.__rlshift__(y) <==> y<<x
__rmod__(...)
x.__rmod__(y) <==> y%x
__rmul__(...)
x.__rmul__(y) <==> y*x
__ror__(...)
x.__ror__(y) <==> y|x
__rpow__(...)
y.__rpow__(x[, z]) <==> pow(x, y[, z])
__rrshift__(...)
x.__rrshift__(y) <==> y>>x
__rshift__(...)
x.__rshift__(y) <==> x>>y
__rsub__(...)
x.__rsub__(y) <==> y-x
__rtruediv__(...)
x.__rtruediv__(y) <==> y/x
__rxor__(...)
x.__rxor__(y) <==> y^x
__setstate__(...)
__sub__(...)
x.__sub__(y) <==> x-y
__truediv__(...)
x.__truediv__(y) <==> x/y
__xor__(...)
x.__xor__(y) <==> x^y
all(...)
any(...)
argmax(...)
argmin(...)
argsort(...)
astype(...)
byteswap(...)
choose(...)
clip(...)
compress(...)
conj(...)
conjugate(...)
copy(...)
cumprod(...)
cumsum(...)
diagonal(...)
dump(...)
dumps(...)
fill(...)
flatten(...)
getfield(...)
item(...)
itemset(...)
max(...)
mean(...)
min(...)
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:
 
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
 
Parameters
----------
new_order : string, 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(...)
prod(...)
ptp(...)
put(...)
ravel(...)
repeat(...)
reshape(...)
resize(...)
round(...)
searchsorted(...)
setfield(...)
setflags(...)
sort(...)
squeeze(...)
std(...)
sum(...)
swapaxes(...)
take(...)
tofile(...)
tolist(...)
tostring(...)
trace(...)
transpose(...)
var(...)
view(...)

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 float32(floating)
    32-bit floating-point number. Character code ``f``.
 
 
Method resolution order:
float32
floating
inexact
number
generic
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 at 0x7f8ebc33b840>
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
__getitem__(...)
x.__getitem__(y) <==> x[y]
__hex__(...)
x.__hex__() <==> hex(x)
__int__(...)
x.__int__() <==> int(x)
__invert__(...)
x.__invert__() <==> ~x
__long__(...)
x.__long__() <==> long(x)
__lshift__(...)
x.__lshift__(y) <==> x<<y
__mod__(...)
x.__mod__(y) <==> x%y
__mul__(...)
x.__mul__(y) <==> x*y
__neg__(...)
x.__neg__() <==> -x
__nonzero__(...)
x.__nonzero__() <==> x != 0
__oct__(...)
x.__oct__() <==> oct(x)
__or__(...)
x.__or__(y) <==> x|y
__pos__(...)
x.__pos__() <==> +x
__pow__(...)
x.__pow__(y[, z]) <==> pow(x, y[, z])
__radd__(...)
x.__radd__(y) <==> y+x
__rand__(...)
x.__rand__(y) <==> y&x
__rdiv__(...)
x.__rdiv__(y) <==> y/x
__rdivmod__(...)
x.__rdivmod__(y) <==> divmod(y, x)
__reduce__(...)
__rfloordiv__(...)
x.__rfloordiv__(y) <==> y//x
__rlshift__(...)
x.__rlshift__(y) <==> y<<x
__rmod__(...)
x.__rmod__(y) <==> y%x
__rmul__(...)
x.__rmul__(y) <==> y*x
__ror__(...)
x.__ror__(y) <==> y|x
__rpow__(...)
y.__rpow__(x[, z]) <==> pow(x, y[, z])
__rrshift__(...)
x.__rrshift__(y) <==> y>>x
__rshift__(...)
x.__rshift__(y) <==> x>>y
__rsub__(...)
x.__rsub__(y) <==> y-x
__rtruediv__(...)
x.__rtruediv__(y) <==> y/x
__rxor__(...)
x.__rxor__(y) <==> y^x
__setstate__(...)
__sub__(...)
x.__sub__(y) <==> x-y
__truediv__(...)
x.__truediv__(y) <==> x/y
__xor__(...)
x.__xor__(y) <==> x^y
all(...)
any(...)
argmax(...)
argmin(...)
argsort(...)
astype(...)
byteswap(...)
choose(...)
clip(...)
compress(...)
conj(...)
conjugate(...)
copy(...)
cumprod(...)
cumsum(...)
diagonal(...)
dump(...)
dumps(...)
fill(...)
flatten(...)
getfield(...)
item(...)
itemset(...)
max(...)
mean(...)
min(...)
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:
 
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
 
Parameters
----------
new_order : string, 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(...)
prod(...)
ptp(...)
put(...)
ravel(...)
repeat(...)
reshape(...)
resize(...)
round(...)
searchsorted(...)
setfield(...)
setflags(...)
sort(...)
squeeze(...)
std(...)
sum(...)
swapaxes(...)
take(...)
tofile(...)
tolist(...)
tostring(...)
trace(...)
transpose(...)
var(...)
view(...)

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 float64(floating, float)
    64-bit floating-point number. Character code ``d``.
 
 
Method resolution order:
float64
floating
inexact
number
generic
float
object

Methods defined here:
__eq__(...)
x.__eq__(y) <==> x==y
__ge__(...)
x.__ge__(y) <==> x>=y
__gt__(...)
x.__gt__(y) <==> x>y
__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 at 0x7f8ebc33b9e0>
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
__getitem__(...)
x.__getitem__(y) <==> x[y]
__hex__(...)
x.__hex__() <==> hex(x)
__int__(...)
x.__int__() <==> int(x)
__invert__(...)
x.__invert__() <==> ~x
__long__(...)
x.__long__() <==> long(x)
__lshift__(...)
x.__lshift__(y) <==> x<<y
__mod__(...)
x.__mod__(y) <==> x%y
__mul__(...)
x.__mul__(y) <==> x*y
__neg__(...)
x.__neg__() <==> -x
__nonzero__(...)
x.__nonzero__() <==> x != 0
__oct__(...)
x.__oct__() <==> oct(x)
__or__(...)
x.__or__(y) <==> x|y
__pos__(...)
x.__pos__() <==> +x
__pow__(...)
x.__pow__(y[, z]) <==> pow(x, y[, z])
__radd__(...)
x.__radd__(y) <==> y+x
__rand__(...)
x.__rand__(y) <==> y&x
__rdiv__(...)
x.__rdiv__(y) <==> y/x
__rdivmod__(...)
x.__rdivmod__(y) <==> divmod(y, x)
__reduce__(...)
__rfloordiv__(...)
x.__rfloordiv__(y) <==> y//x
__rlshift__(...)
x.__rlshift__(y) <==> y<<x
__rmod__(...)
x.__rmod__(y) <==> y%x
__rmul__(...)
x.__rmul__(y) <==> y*x
__ror__(...)
x.__ror__(y) <==> y|x
__rpow__(...)
y.__rpow__(x[, z]) <==> pow(x, y[, z])
__rrshift__(...)
x.__rrshift__(y) <==> y>>x
__rshift__(...)
x.__rshift__(y) <==> x>>y
__rsub__(...)
x.__rsub__(y) <==> y-x
__rtruediv__(...)
x.__rtruediv__(y) <==> y/x
__rxor__(...)
x.__rxor__(y) <==> y^x
__setstate__(...)
__sub__(...)
x.__sub__(y) <==> x-y
__truediv__(...)
x.__truediv__(y) <==> x/y
__xor__(...)
x.__xor__(y) <==> x^y
all(...)
any(...)
argmax(...)
argmin(...)
argsort(...)
astype(...)
byteswap(...)
choose(...)
clip(...)
compress(...)
conj(...)
conjugate(...)
copy(...)
cumprod(...)
cumsum(...)
diagonal(...)
dump(...)
dumps(...)
fill(...)
flatten(...)
getfield(...)
item(...)
itemset(...)
max(...)
mean(...)
min(...)
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:
 
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
 
Parameters
----------
new_order : string, 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(...)
prod(...)
ptp(...)
put(...)
ravel(...)
repeat(...)
reshape(...)
resize(...)
round(...)
searchsorted(...)
setfield(...)
setflags(...)
sort(...)
squeeze(...)
std(...)
sum(...)
swapaxes(...)
take(...)
tofile(...)
tolist(...)
tostring(...)
trace(...)
transpose(...)
var(...)
view(...)

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

Methods inherited from float:
__coerce__(...)
x.__coerce__(y) <==> coerce(x, y)
__format__(...)
float.__format__(format_spec) -> string
 
Formats the float according to format_spec.
__getattribute__(...)
x.__getattribute__('name') <==> x.name
__getnewargs__(...)
__hash__(...)
x.__hash__() <==> hash(x)
__trunc__(...)
Returns the Integral closest to x between 0 and x.
as_integer_ratio(...)
float.as_integer_ratio() -> (intint)
 
Returns a pair of integers, whose ratio is exactly equal to the original
float and with a positive denominator.
Raises OverflowError on infinities and a ValueError on NaNs.
 
>>> (10.0).as_integer_ratio()
(10, 1)
>>> (0.0).as_integer_ratio()
(0, 1)
>>> (-.25).as_integer_ratio()
(-1, 4)
hex(...)
float.hex() -> string
 
Return a hexadecimal representation of a floating-point number.
>>> (-0.1).hex()
'-0x1.999999999999ap-4'
>>> 3.14159.hex()
'0x1.921f9f01b866ep+1'
is_integer(...)
Returns True if the float is an integer.

Data and other attributes inherited from float:
__getformat__ = <built-in method __getformat__ of type object at 0x7f8ebc33b9e0>
float.__getformat__(typestr) -> string
 
You probably don't want to use this function.  It exists mainly to be
used in Python's test suite.
 
typestr must be 'double' or 'float'.  This function returns whichever of
'unknown', 'IEEE, big-endian' or 'IEEE, little-endian' best describes the
format of floating point numbers used by the C type named by typestr.
__setformat__ = <built-in method __setformat__ of type object at 0x7f8ebc33b9e0>
float.__setformat__(typestr, fmt) -> None
 
You probably don't want to use this function.  It exists mainly to be
used in Python's test suite.
 
typestr must be 'double' or 'float'.  fmt must be one of 'unknown',
'IEEE, big-endian' or 'IEEE, little-endian', and in addition can only be
one of the latter two if it appears to match the underlying C reality.
 
Overrides the automatic determination of C-level floating point type.
This affects how floats are converted to and from binary strings.
fromhex = <built-in method fromhex of type object at 0x7f8ebc33b9e0>
float.fromhex(string) -> float
 
Create a floating-point number from a hexadecimal string.
>>> float.fromhex('0x1.ffffp10')
2047.984375
>>> float.fromhex('-0x1p-1074')
-4.9406564584124654e-324

 
float_ = class float64(floating, float)
    64-bit floating-point number. Character code ``d``.
 
 
Method resolution order:
float64
floating
inexact
number
generic
float
object

Methods defined here:
__eq__(...)
x.__eq__(y) <==> x==y
__ge__(...)
x.__ge__(y) <==> x>=y
__gt__(...)
x.__gt__(y) <==> x>y
__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 at 0x7f8ebc33b9e0>
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
__getitem__(...)
x.__getitem__(y) <==> x[y]
__hex__(...)
x.__hex__() <==> hex(x)
__int__(...)
x.__int__() <==> int(x)
__invert__(...)
x.__invert__() <==> ~x
__long__(...)
x.__long__() <==> long(x)
__lshift__(...)
x.__lshift__(y) <==> x<<y
__mod__(...)
x.__mod__(y) <==> x%y
__mul__(...)
x.__mul__(y) <==> x*y
__neg__(...)
x.__neg__() <==> -x
__nonzero__(...)
x.__nonzero__() <==> x != 0
__oct__(...)
x.__oct__() <==> oct(x)
__or__(...)
x.__or__(y) <==> x|y
__pos__(...)
x.__pos__() <==> +x
__pow__(...)
x.__pow__(y[, z]) <==> pow(x, y[, z])
__radd__(...)
x.__radd__(y) <==> y+x
__rand__(...)
x.__rand__(y) <==> y&x
__rdiv__(...)
x.__rdiv__(y) <==> y/x
__rdivmod__(...)
x.__rdivmod__(y) <==> divmod(y, x)
__reduce__(...)
__rfloordiv__(...)
x.__rfloordiv__(y) <==> y//x
__rlshift__(...)
x.__rlshift__(y) <==> y<<x
__rmod__(...)
x.__rmod__(y) <==> y%x
__rmul__(...)
x.__rmul__(y) <==> y*x
__ror__(...)
x.__ror__(y) <==> y|x
__rpow__(...)
y.__rpow__(x[, z]) <==> pow(x, y[, z])
__rrshift__(...)
x.__rrshift__(y) <==> y>>x
__rshift__(...)
x.__rshift__(y) <==> x>>y
__rsub__(...)
x.__rsub__(y) <==> y-x
__rtruediv__(...)
x.__rtruediv__(y) <==> y/x
__rxor__(...)
x.__rxor__(y) <==> y^x
__setstate__(...)
__sub__(...)
x.__sub__(y) <==> x-y
__truediv__(...)
x.__truediv__(y) <==> x/y
__xor__(...)
x.__xor__(y) <==> x^y
all(...)
any(...)
argmax(...)
argmin(...)
argsort(...)
astype(...)
byteswap(...)
choose(...)
clip(...)
compress(...)
conj(...)
conjugate(...)
copy(...)
cumprod(...)
cumsum(...)
diagonal(...)
dump(...)
dumps(...)
fill(...)
flatten(...)
getfield(...)
item(...)
itemset(...)
max(...)
mean(...)
min(...)
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:
 
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
 
Parameters
----------
new_order : string, 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(...)
prod(...)
ptp(...)
put(...)
ravel(...)
repeat(...)
reshape(...)
resize(...)
round(...)
searchsorted(...)
setfield(...)
setflags(...)
sort(...)
squeeze(...)
std(...)
sum(...)
swapaxes(...)
take(...)
tofile(...)
tolist(...)
tostring(...)
trace(...)
transpose(...)
var(...)
view(...)

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

Methods inherited from float:
__coerce__(...)
x.__coerce__(y) <==> coerce(x, y)
__format__(...)
float.__format__(format_spec) -> string
 
Formats the float according to format_spec.
__getattribute__(...)
x.__getattribute__('name') <==> x.name
__getnewargs__(...)
__hash__(...)
x.__hash__() <==> hash(x)
__trunc__(...)
Returns the Integral closest to x between 0 and x.
as_integer_ratio(...)
float.as_integer_ratio() -> (intint)
 
Returns a pair of integers, whose ratio is exactly equal to the original
float and with a positive denominator.
Raises OverflowError on infinities and a ValueError on NaNs.
 
>>> (10.0).as_integer_ratio()
(10, 1)
>>> (0.0).as_integer_ratio()
(0, 1)
>>> (-.25).as_integer_ratio()
(-1, 4)
hex(...)
float.hex() -> string
 
Return a hexadecimal representation of a floating-point number.
>>> (-0.1).hex()
'-0x1.999999999999ap-4'
>>> 3.14159.hex()
'0x1.921f9f01b866ep+1'
is_integer(...)
Returns True if the float is an integer.

Data and other attributes inherited from float:
__getformat__ = <built-in method __getformat__ of type object at 0x7f8ebc33b9e0>
float.__getformat__(typestr) -> string
 
You probably don't want to use this function.  It exists mainly to be
used in Python's test suite.
 
typestr must be 'double' or 'float'.  This function returns whichever of
'unknown', 'IEEE, big-endian' or 'IEEE, little-endian' best describes the
format of floating point numbers used by the C type named by typestr.
__setformat__ = <built-in method __setformat__ of type object at 0x7f8ebc33b9e0>
float.__setformat__(typestr, fmt) -> None
 
You probably don't want to use this function.  It exists mainly to be
used in Python's test suite.
 
typestr must be 'double' or 'float'.  fmt must be one of 'unknown',
'IEEE, big-endian' or 'IEEE, little-endian', and in addition can only be
one of the latter two if it appears to match the underlying C reality.
 
Overrides the automatic determination of C-level floating point type.
This affects how floats are converted to and from binary strings.
fromhex = <built-in method fromhex of type object at 0x7f8ebc33b9e0>
float.fromhex(string) -> float
 
Create a floating-point number from a hexadecimal string.
>>> float.fromhex('0x1.ffffp10')
2047.984375
>>> float.fromhex('-0x1p-1074')
-4.9406564584124654e-324

 
class floating(inexact)
    
Method resolution order:
floating
inexact
number
generic
object

Methods inherited from generic:
__abs__(...)
x.__abs__() <==> abs(x)
__add__(...)
x.__add__(y) <==> x+y
__and__(...)
x.__and__(y) <==> x&y
__array__(...)
sc.__array__(|type) return 0-dim array
__array_wrap__(...)
sc.__array_wrap__(obj) return scalar from array
__copy__(...)
__deepcopy__(...)
__div__(...)
x.__div__(y) <==> x/y
__divmod__(...)
x.__divmod__(y) <==> divmod(x, y)
__eq__(...)
x.__eq__(y) <==> x==y
__float__(...)
x.__float__() <==> float(x)
__floordiv__(...)
x.__floordiv__(y) <==> x//y
__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__(...)
__str__(...)
x.__str__() <==> str(x)
__sub__(...)
x.__sub__(y) <==> x-y
__truediv__(...)
x.__truediv__(y) <==> x/y
__xor__(...)
x.__xor__(y) <==> x^y
all(...)
any(...)
argmax(...)
argmin(...)
argsort(...)
astype(...)
byteswap(...)
choose(...)
clip(...)
compress(...)
conj(...)
conjugate(...)
copy(...)
cumprod(...)
cumsum(...)
diagonal(...)
dump(...)
dumps(...)
fill(...)
flatten(...)
getfield(...)
item(...)
itemset(...)
max(...)
mean(...)
min(...)
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:
 
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
 
Parameters
----------
new_order : string, 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(...)
prod(...)
ptp(...)
put(...)
ravel(...)
repeat(...)
reshape(...)
resize(...)
round(...)
searchsorted(...)
setfield(...)
setflags(...)
sort(...)
squeeze(...)
std(...)
sum(...)
swapaxes(...)
take(...)
tofile(...)
tolist(...)
tostring(...)
trace(...)
transpose(...)
var(...)
view(...)

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 generic(object)
     Methods defined here:
__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
__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__(...)
__str__(...)
x.__str__() <==> str(x)
__sub__(...)
x.__sub__(y) <==> x-y
__truediv__(...)
x.__truediv__(y) <==> x/y
__xor__(...)
x.__xor__(y) <==> x^y
all(...)
any(...)
argmax(...)
argmin(...)
argsort(...)
astype(...)
byteswap(...)
choose(...)
clip(...)
compress(...)
conj(...)
conjugate(...)
copy(...)
cumprod(...)
cumsum(...)
diagonal(...)
dump(...)
dumps(...)
fill(...)
flatten(...)
getfield(...)
item(...)
itemset(...)
max(...)
mean(...)
min(...)
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:
 
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
 
Parameters
----------
new_order : string, 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(...)
prod(...)
ptp(...)
put(...)
ravel(...)
repeat(...)
reshape(...)
resize(...)
round(...)
searchsorted(...)
setfield(...)
setflags(...)
sort(...)
squeeze(...)
std(...)
sum(...)
swapaxes(...)
take(...)
tofile(...)
tolist(...)
tostring(...)
trace(...)
transpose(...)
var(...)
view(...)

Data descriptors defined here:
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 inexact(number)
    
Method resolution order:
inexact
number
generic
object

Methods inherited from generic:
__abs__(...)
x.__abs__() <==> abs(x)
__add__(...)
x.__add__(y) <==> x+y
__and__(...)
x.__and__(y) <==> x&y
__array__(...)
sc.__array__(|type) return 0-dim array
__array_wrap__(...)
sc.__array_wrap__(obj) return scalar from array
__copy__(...)
__deepcopy__(...)
__div__(...)
x.__div__(y) <==> x/y
__divmod__(...)
x.__divmod__(y) <==> divmod(x, y)
__eq__(...)
x.__eq__(y) <==> x==y
__float__(...)
x.__float__() <==> float(x)
__floordiv__(...)
x.__floordiv__(y) <==> x//y
__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__(...)
__str__(...)
x.__str__() <==> str(x)
__sub__(...)
x.__sub__(y) <==> x-y
__truediv__(...)
x.__truediv__(y) <==> x/y
__xor__(...)
x.__xor__(y) <==> x^y
all(...)
any(...)
argmax(...)
argmin(...)
argsort(...)
astype(...)
byteswap(...)
choose(...)
clip(...)
compress(...)
conj(...)
conjugate(...)
copy(...)
cumprod(...)
cumsum(...)
diagonal(...)
dump(...)
dumps(...)
fill(...)
flatten(...)
getfield(...)
item(...)
itemset(...)
max(...)
mean(...)
min(...)
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:
 
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
 
Parameters
----------
new_order : string, 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(...)
prod(...)
ptp(...)
put(...)
ravel(...)
repeat(...)
reshape(...)
resize(...)
round(...)
searchsorted(...)
setfield(...)
setflags(...)
sort(...)
squeeze(...)
std(...)
sum(...)
swapaxes(...)
take(...)
tofile(...)
tolist(...)
tostring(...)
trace(...)
transpose(...)
var(...)
view(...)

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

 
int0 = class int64(signedinteger, int)
    64-bit integer. Character code ``i8``.
 
 
Method resolution order:
int64
signedinteger
integer
number
generic
int
object

Methods defined here:
__eq__(...)
x.__eq__(y) <==> x==y
__ge__(...)
x.__ge__(y) <==> x>=y
__gt__(...)
x.__gt__(y) <==> x>y
__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 at 0x7f8ebc33ace0>
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
__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__(...)
__str__(...)
x.__str__() <==> str(x)
__sub__(...)
x.__sub__(y) <==> x-y
__truediv__(...)
x.__truediv__(y) <==> x/y
__xor__(...)
x.__xor__(y) <==> x^y
all(...)
any(...)
argmax(...)
argmin(...)
argsort(...)
astype(...)
byteswap(...)
choose(...)
clip(...)
compress(...)
conj(...)
conjugate(...)
copy(...)
cumprod(...)
cumsum(...)
diagonal(...)
dump(...)
dumps(...)
fill(...)
flatten(...)
getfield(...)
item(...)
itemset(...)
max(...)
mean(...)
min(...)
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:
 
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
 
Parameters
----------
new_order : string, 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(...)
prod(...)
ptp(...)
put(...)
ravel(...)
repeat(...)
reshape(...)
resize(...)
round(...)
searchsorted(...)
setfield(...)
setflags(...)
sort(...)
squeeze(...)
std(...)
sum(...)
swapaxes(...)
take(...)
tofile(...)
tolist(...)
tostring(...)
trace(...)
transpose(...)
var(...)
view(...)

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

Methods inherited from int:
__cmp__(...)
x.__cmp__(y) <==> cmp(x,y)
__coerce__(...)
x.__coerce__(y) <==> coerce(x, y)
__format__(...)
__getattribute__(...)
x.__getattribute__('name') <==> x.name
__getnewargs__(...)
__hash__(...)
x.__hash__() <==> hash(x)
__trunc__(...)
Truncating an Integral returns itself.

Data descriptors inherited from int:
denominator
the denominator of a rational number in lowest terms
numerator
the numerator of a rational number in lowest terms

 
class int16(signedinteger)
    16-bit integer. Character code ``h``.
 
 
Method resolution order:
int16
signedinteger
integer
number
generic
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 at 0x7f8ebc33a9a0>
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
__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__(...)
__str__(...)
x.__str__() <==> str(x)
__sub__(...)
x.__sub__(y) <==> x-y
__truediv__(...)
x.__truediv__(y) <==> x/y
__xor__(...)
x.__xor__(y) <==> x^y
all(...)
any(...)
argmax(...)
argmin(...)
argsort(...)
astype(...)
byteswap(...)
choose(...)
clip(...)
compress(...)
conj(...)
conjugate(...)
copy(...)
cumprod(...)
cumsum(...)
diagonal(...)
dump(...)
dumps(...)
fill(...)
flatten(...)
getfield(...)
item(...)
itemset(...)
max(...)
mean(...)
min(...)
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:
 
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
 
Parameters
----------
new_order : string, 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(...)
prod(...)
ptp(...)
put(...)
ravel(...)
repeat(...)
reshape(...)
resize(...)
round(...)
searchsorted(...)
setfield(...)
setflags(...)
sort(...)
squeeze(...)
std(...)
sum(...)
swapaxes(...)
take(...)
tofile(...)
tolist(...)
tostring(...)
trace(...)
transpose(...)
var(...)
view(...)

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 int32(signedinteger)
    32-bit integer. Character code ``i4``.
 
 
Method resolution order:
int32
signedinteger
integer
number
generic
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 at 0x7f8ebc33ab40>
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
__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__(...)
__str__(...)
x.__str__() <==> str(x)
__sub__(...)
x.__sub__(y) <==> x-y
__truediv__(...)
x.__truediv__(y) <==> x/y
__xor__(...)
x.__xor__(y) <==> x^y
all(...)
any(...)
argmax(...)
argmin(...)
argsort(...)
astype(...)
byteswap(...)
choose(...)
clip(...)
compress(...)
conj(...)
conjugate(...)
copy(...)
cumprod(...)
cumsum(...)
diagonal(...)
dump(...)
dumps(...)
fill(...)
flatten(...)
getfield(...)
item(...)
itemset(...)
max(...)
mean(...)
min(...)
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:
 
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
 
Parameters
----------
new_order : string, 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(...)
prod(...)
ptp(...)
put(...)
ravel(...)
repeat(...)
reshape(...)
resize(...)
round(...)
searchsorted(...)
setfield(...)
setflags(...)
sort(...)
squeeze(...)
std(...)
sum(...)
swapaxes(...)
take(...)
tofile(...)
tolist(...)
tostring(...)
trace(...)
transpose(...)
var(...)
view(...)

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 int64(signedinteger, int)
    64-bit integer. Character code ``i8``.
 
 
Method resolution order:
int64
signedinteger
integer
number
generic
int
object

Methods defined here:
__eq__(...)
x.__eq__(y) <==> x==y
__ge__(...)
x.__ge__(y) <==> x>=y
__gt__(...)
x.__gt__(y) <==> x>y
__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 at 0x7f8ebc33ace0>
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
__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__(...)
__str__(...)
x.__str__() <==> str(x)
__sub__(...)
x.__sub__(y) <==> x-y
__truediv__(...)
x.__truediv__(y) <==> x/y
__xor__(...)
x.__xor__(y) <==> x^y
all(...)
any(...)
argmax(...)
argmin(...)
argsort(...)
astype(...)
byteswap(...)
choose(...)
clip(...)
compress(...)
conj(...)
conjugate(...)
copy(...)
cumprod(...)
cumsum(...)
diagonal(...)
dump(...)
dumps(...)
fill(...)
flatten(...)
getfield(...)
item(...)
itemset(...)
max(...)
mean(...)
min(...)
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:
 
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
 
Parameters
----------
new_order : string, 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(...)
prod(...)
ptp(...)
put(...)
ravel(...)
repeat(...)
reshape(...)
resize(...)
round(...)
searchsorted(...)
setfield(...)
setflags(...)
sort(...)
squeeze(...)
std(...)
sum(...)
swapaxes(...)
take(...)
tofile(...)
tolist(...)
tostring(...)
trace(...)
transpose(...)
var(...)
view(...)

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

Methods inherited from int:
__cmp__(...)
x.__cmp__(y) <==> cmp(x,y)
__coerce__(...)
x.__coerce__(y) <==> coerce(x, y)
__format__(...)
__getattribute__(...)
x.__getattribute__('name') <==> x.name
__getnewargs__(...)
__hash__(...)
x.__hash__() <==> hash(x)
__trunc__(...)
Truncating an Integral returns itself.

Data descriptors inherited from int:
denominator
the denominator of a rational number in lowest terms
numerator
the numerator of a rational number in lowest terms

 
class int8(signedinteger)
    8-bit integer. Character code ``b``.
 
 
Method resolution order:
int8
signedinteger
integer
number
generic
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 at 0x7f8ebc33a800>
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
__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__(...)
__str__(...)
x.__str__() <==> str(x)
__sub__(...)
x.__sub__(y) <==> x-y
__truediv__(...)
x.__truediv__(y) <==> x/y
__xor__(...)
x.__xor__(y) <==> x^y
all(...)
any(...)
argmax(...)
argmin(...)
argsort(...)
astype(...)
byteswap(...)
choose(...)
clip(...)
compress(...)
conj(...)
conjugate(...)
copy(...)
cumprod(...)
cumsum(...)
diagonal(...)
dump(...)
dumps(...)
fill(...)
flatten(...)
getfield(...)
item(...)
itemset(...)
max(...)
mean(...)
min(...)
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:
 
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
 
Parameters
----------
new_order : string, 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(...)
prod(...)
ptp(...)
put(...)
ravel(...)
repeat(...)
reshape(...)
resize(...)
round(...)
searchsorted(...)
setfield(...)
setflags(...)
sort(...)
squeeze(...)
std(...)
sum(...)
swapaxes(...)
take(...)
tofile(...)
tolist(...)
tostring(...)
trace(...)
transpose(...)
var(...)
view(...)

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

 
int_ = class int64(signedinteger, int)
    64-bit integer. Character code ``i8``.
 
 
Method resolution order:
int64
signedinteger
integer
number
generic
int
object

Methods defined here:
__eq__(...)
x.__eq__(y) <==> x==y
__ge__(...)
x.__ge__(y) <==> x>=y
__gt__(...)
x.__gt__(y) <==> x>y
__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 at 0x7f8ebc33ace0>
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
__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__(...)
__str__(...)
x.__str__() <==> str(x)
__sub__(...)
x.__sub__(y) <==> x-y
__truediv__(...)
x.__truediv__(y) <==> x/y
__xor__(...)
x.__xor__(y) <==> x^y
all(...)
any(...)
argmax(...)
argmin(...)
argsort(...)
astype(...)
byteswap(...)
choose(...)
clip(...)
compress(...)
conj(...)
conjugate(...)
copy(...)
cumprod(...)
cumsum(...)
diagonal(...)
dump(...)
dumps(...)
fill(...)
flatten(...)
getfield(...)
item(...)
itemset(...)
max(...)
mean(...)
min(...)
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:
 
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
 
Parameters
----------
new_order : string, 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(...)
prod(...)
ptp(...)
put(...)
ravel(...)
repeat(...)
reshape(...)
resize(...)
round(...)
searchsorted(...)
setfield(...)
setflags(...)
sort(...)
squeeze(...)
std(...)
sum(...)
swapaxes(...)
take(...)
tofile(...)
tolist(...)
tostring(...)
trace(...)
transpose(...)
var(...)
view(...)

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

Methods inherited from int:
__cmp__(...)
x.__cmp__(y) <==> cmp(x,y)
__coerce__(...)
x.__coerce__(y) <==> coerce(x, y)
__format__(...)
__getattribute__(...)
x.__getattribute__('name') <==> x.name
__getnewargs__(...)
__hash__(...)
x.__hash__() <==> hash(x)
__trunc__(...)
Truncating an Integral returns itself.

Data descriptors inherited from int:
denominator
the denominator of a rational number in lowest terms
numerator
the numerator of a rational number in lowest terms

 
intc = class int32(signedinteger)
    32-bit integer. Character code ``i4``.
 
 
Method resolution order:
int32
signedinteger
integer
number
generic
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 at 0x7f8ebc33ab40>
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
__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__(...)
__str__(...)
x.__str__() <==> str(x)
__sub__(...)
x.__sub__(y) <==> x-y
__truediv__(...)
x.__truediv__(y) <==> x/y
__xor__(...)
x.__xor__(y) <==> x^y
all(...)
any(...)
argmax(...)
argmin(...)
argsort(...)
astype(...)
byteswap(...)
choose(...)
clip(...)
compress(...)
conj(...)
conjugate(...)
copy(...)
cumprod(...)
cumsum(...)
diagonal(...)
dump(...)
dumps(...)
fill(...)
flatten(...)
getfield(...)
item(...)
itemset(...)
max(...)
mean(...)
min(...)
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:
 
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
 
Parameters
----------
new_order : string, 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(...)
prod(...)
ptp(...)
put(...)
ravel(...)
repeat(...)
reshape(...)
resize(...)
round(...)
searchsorted(...)
setfield(...)
setflags(...)
sort(...)
squeeze(...)
std(...)
sum(...)
swapaxes(...)
take(...)
tofile(...)
tolist(...)
tostring(...)
trace(...)
transpose(...)
var(...)
view(...)

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 integer(number)
    
Method resolution order:
integer
number
generic
object

Methods inherited from generic:
__abs__(...)
x.__abs__() <==> abs(x)
__add__(...)
x.__add__(y) <==> x+y
__and__(...)
x.__and__(y) <==> x&y
__array__(...)
sc.__array__(|type) return 0-dim array
__array_wrap__(...)
sc.__array_wrap__(obj) return scalar from array
__copy__(...)
__deepcopy__(...)
__div__(...)
x.__div__(y) <==> x/y
__divmod__(...)
x.__divmod__(y) <==> divmod(x, y)
__eq__(...)
x.__eq__(y) <==> x==y
__float__(...)
x.__float__() <==> float(x)
__floordiv__(...)
x.__floordiv__(y) <==> x//y
__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__(...)
__str__(...)
x.__str__() <==> str(x)
__sub__(...)
x.__sub__(y) <==> x-y
__truediv__(...)
x.__truediv__(y) <==> x/y
__xor__(...)
x.__xor__(y) <==> x^y
all(...)
any(...)
argmax(...)
argmin(...)
argsort(...)
astype(...)
byteswap(...)
choose(...)
clip(...)
compress(...)
conj(...)
conjugate(...)
copy(...)
cumprod(...)
cumsum(...)
diagonal(...)
dump(...)
dumps(...)
fill(...)
flatten(...)
getfield(...)
item(...)
itemset(...)
max(...)
mean(...)
min(...)
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:
 
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
 
Parameters
----------
new_order : string, 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(...)
prod(...)
ptp(...)
put(...)
ravel(...)
repeat(...)
reshape(...)
resize(...)
round(...)
searchsorted(...)
setfield(...)
setflags(...)
sort(...)
squeeze(...)
std(...)
sum(...)
swapaxes(...)
take(...)
tofile(...)
tolist(...)
tostring(...)
trace(...)
transpose(...)
var(...)
view(...)

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

 
intp = class int64(signedinteger, int)
    64-bit integer. Character code ``i8``.
 
 
Method resolution order:
int64
signedinteger
integer
number
generic
int
object

Methods defined here:
__eq__(...)
x.__eq__(y) <==> x==y
__ge__(...)
x.__ge__(y) <==> x>=y
__gt__(...)
x.__gt__(y) <==> x>y
__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 at 0x7f8ebc33ace0>
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
__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__(...)
__str__(...)
x.__str__() <==> str(x)
__sub__(...)
x.__sub__(y) <==> x-y
__truediv__(...)
x.__truediv__(y) <==> x/y
__xor__(...)
x.__xor__(y) <==> x^y
all(...)
any(...)
argmax(...)
argmin(...)
argsort(...)
astype(...)
byteswap(...)
choose(...)
clip(...)
compress(...)
conj(...)
conjugate(...)
copy(...)
cumprod(...)
cumsum(...)
diagonal(...)
dump(...)
dumps(...)
fill(...)
flatten(...)
getfield(...)
item(...)
itemset(...)
max(...)
mean(...)
min(...)
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:
 
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
 
Parameters
----------
new_order : string, 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(...)
prod(...)
ptp(...)
put(...)
ravel(...)
repeat(...)
reshape(...)
resize(...)
round(...)
searchsorted(...)
setfield(...)
setflags(...)
sort(...)
squeeze(...)
std(...)
sum(...)
swapaxes(...)
take(...)
tofile(...)
tolist(...)
tostring(...)
trace(...)
transpose(...)
var(...)
view(...)

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

Methods inherited from int:
__cmp__(...)
x.__cmp__(y) <==> cmp(x,y)
__coerce__(...)
x.__coerce__(y) <==> coerce(x, y)
__format__(...)
__getattribute__(...)
x.__getattribute__('name') <==> x.name
__getnewargs__(...)
__hash__(...)
x.__hash__() <==> hash(x)
__trunc__(...)
Truncating an Integral returns itself.

Data descriptors inherited from int:
denominator
the denominator of a rational number in lowest terms
numerator
the numerator of a rational number in lowest terms

 
longcomplex = class complex256(complexfloating)
    Composed of two 128 bit floats
 
 
Method resolution order:
complex256
complexfloating
inexact
number
generic
object

Methods defined here:
__eq__(...)
x.__eq__(y) <==> x==y
__float__(...)
x.__float__() <==> float(x)
__ge__(...)
x.__ge__(y) <==> x>=y
__gt__(...)
x.__gt__(y) <==> x>y
__hash__(...)
x.__hash__() <==> hash(x)
__hex__(...)
x.__hex__() <==> hex(x)
__int__(...)
x.__int__() <==> int(x)
__le__(...)
x.__le__(y) <==> x<=y
__long__(...)
x.__long__() <==> long(x)
__lt__(...)
x.__lt__(y) <==> x<y
__ne__(...)
x.__ne__(y) <==> x!=y
__oct__(...)
x.__oct__() <==> oct(x)
__repr__(...)
x.__repr__() <==> repr(x)
__str__(...)
x.__str__() <==> str(x)

Data and other attributes defined here:
__new__ = <built-in method __new__ of type object at 0x7f8ebc33c060>
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)
__floordiv__(...)
x.__floordiv__(y) <==> x//y
__getitem__(...)
x.__getitem__(y) <==> x[y]
__invert__(...)
x.__invert__() <==> ~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
__or__(...)
x.__or__(y) <==> x|y
__pos__(...)
x.__pos__() <==> +x
__pow__(...)
x.__pow__(y[, z]) <==> pow(x, y[, z])
__radd__(...)
x.__radd__(y) <==> y+x
__rand__(...)
x.__rand__(y) <==> y&x
__rdiv__(...)
x.__rdiv__(y) <==> y/x
__rdivmod__(...)
x.__rdivmod__(y) <==> divmod(y, x)
__reduce__(...)
__rfloordiv__(...)
x.__rfloordiv__(y) <==> y//x
__rlshift__(...)
x.__rlshift__(y) <==> y<<x
__rmod__(...)
x.__rmod__(y) <==> y%x
__rmul__(...)
x.__rmul__(y) <==> y*x
__ror__(...)
x.__ror__(y) <==> y|x
__rpow__(...)
y.__rpow__(x[, z]) <==> pow(x, y[, z])
__rrshift__(...)
x.__rrshift__(y) <==> y>>x
__rshift__(...)
x.__rshift__(y) <==> x>>y
__rsub__(...)
x.__rsub__(y) <==> y-x
__rtruediv__(...)
x.__rtruediv__(y) <==> y/x
__rxor__(...)
x.__rxor__(y) <==> y^x
__setstate__(...)
__sub__(...)
x.__sub__(y) <==> x-y
__truediv__(...)
x.__truediv__(y) <==> x/y
__xor__(...)
x.__xor__(y) <==> x^y
all(...)
any(...)
argmax(...)
argmin(...)
argsort(...)
astype(...)
byteswap(...)
choose(...)
clip(...)
compress(...)
conj(...)
conjugate(...)
copy(...)
cumprod(...)
cumsum(...)
diagonal(...)
dump(...)
dumps(...)
fill(...)
flatten(...)
getfield(...)
item(...)
itemset(...)
max(...)
mean(...)
min(...)
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:
 
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
 
Parameters
----------
new_order : string, 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(...)
prod(...)
ptp(...)
put(...)
ravel(...)
repeat(...)
reshape(...)
resize(...)
round(...)
searchsorted(...)
setfield(...)
setflags(...)
sort(...)
squeeze(...)
std(...)
sum(...)
swapaxes(...)
take(...)
tofile(...)
tolist(...)
tostring(...)
trace(...)
transpose(...)
var(...)
view(...)

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

 
longdouble = class float128(floating)
    
Method resolution order:
float128
floating
inexact
number
generic
object

Methods defined here:
__eq__(...)
x.__eq__(y) <==> x==y
__float__(...)
x.__float__() <==> float(x)
__ge__(...)
x.__ge__(y) <==> x>=y
__gt__(...)
x.__gt__(y) <==> x>y
__hash__(...)
x.__hash__() <==> hash(x)
__hex__(...)
x.__hex__() <==> hex(x)
__int__(...)
x.__int__() <==> int(x)
__le__(...)
x.__le__(y) <==> x<=y
__long__(...)
x.__long__() <==> long(x)
__lt__(...)
x.__lt__(y) <==> x<y
__ne__(...)
x.__ne__(y) <==> x!=y
__oct__(...)
x.__oct__() <==> oct(x)
__repr__(...)
x.__repr__() <==> repr(x)
__str__(...)
x.__str__() <==> str(x)

Data and other attributes defined here:
__new__ = <built-in method __new__ of type object at 0x7f8ebc33bb80>
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)
__floordiv__(...)
x.__floordiv__(y) <==> x//y
__getitem__(...)
x.__getitem__(y) <==> x[y]
__invert__(...)
x.__invert__() <==> ~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
__or__(...)
x.__or__(y) <==> x|y
__pos__(...)
x.__pos__() <==> +x
__pow__(...)
x.__pow__(y[, z]) <==> pow(x, y[, z])
__radd__(...)
x.__radd__(y) <==> y+x
__rand__(...)
x.__rand__(y) <==> y&x
__rdiv__(...)
x.__rdiv__(y) <==> y/x
__rdivmod__(...)
x.__rdivmod__(y) <==> divmod(y, x)
__reduce__(...)
__rfloordiv__(...)
x.__rfloordiv__(y) <==> y//x
__rlshift__(...)
x.__rlshift__(y) <==> y<<x
__rmod__(...)
x.__rmod__(y) <==> y%x
__rmul__(...)
x.__rmul__(y) <==> y*x
__ror__(...)
x.__ror__(y) <==> y|x
__rpow__(...)
y.__rpow__(x[, z]) <==> pow(x, y[, z])
__rrshift__(...)
x.__rrshift__(y) <==> y>>x
__rshift__(...)
x.__rshift__(y) <==> x>>y
__rsub__(...)
x.__rsub__(y) <==> y-x
__rtruediv__(...)
x.__rtruediv__(y) <==> y/x
__rxor__(...)
x.__rxor__(y) <==> y^x
__setstate__(...)
__sub__(...)
x.__sub__(y) <==> x-y
__truediv__(...)
x.__truediv__(y) <==> x/y
__xor__(...)
x.__xor__(y) <==> x^y
all(...)
any(...)
argmax(...)
argmin(...)
argsort(...)
astype(...)
byteswap(...)
choose(...)
clip(...)
compress(...)
conj(...)
conjugate(...)
copy(...)
cumprod(...)
cumsum(...)
diagonal(...)
dump(...)
dumps(...)
fill(...)
flatten(...)
getfield(...)
item(...)
itemset(...)
max(...)
mean(...)
min(...)
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:
 
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
 
Parameters
----------
new_order : string, 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(...)
prod(...)
ptp(...)
put(...)
ravel(...)
repeat(...)
reshape(...)
resize(...)
round(...)
searchsorted(...)
setfield(...)
setflags(...)
sort(...)
squeeze(...)
std(...)
sum(...)
swapaxes(...)
take(...)
tofile(...)
tolist(...)
tostring(...)
trace(...)
transpose(...)
var(...)
view(...)

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

 
longfloat = class float128(floating)
    
Method resolution order:
float128
floating
inexact
number
generic
object

Methods defined here:
__eq__(...)
x.__eq__(y) <==> x==y
__float__(...)
x.__float__() <==> float(x)
__ge__(...)
x.__ge__(y) <==> x>=y
__gt__(...)
x.__gt__(y) <==> x>y
__hash__(...)
x.__hash__() <==> hash(x)
__hex__(...)
x.__hex__() <==> hex(x)
__int__(...)
x.__int__() <==> int(x)
__le__(...)
x.__le__(y) <==> x<=y
__long__(...)
x.__long__() <==> long(x)
__lt__(...)
x.__lt__(y) <==> x<y
__ne__(...)
x.__ne__(y) <==> x!=y
__oct__(...)
x.__oct__() <==> oct(x)
__repr__(...)
x.__repr__() <==> repr(x)
__str__(...)
x.__str__() <==> str(x)

Data and other attributes defined here:
__new__ = <built-in method __new__ of type object at 0x7f8ebc33bb80>
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)
__floordiv__(...)
x.__floordiv__(y) <==> x//y
__getitem__(...)
x.__getitem__(y) <==> x[y]
__invert__(...)
x.__invert__() <==> ~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
__or__(...)
x.__or__(y) <==> x|y
__pos__(...)
x.__pos__() <==> +x
__pow__(...)
x.__pow__(y[, z]) <==> pow(x, y[, z])
__radd__(...)
x.__radd__(y) <==> y+x
__rand__(...)
x.__rand__(y) <==> y&x
__rdiv__(...)
x.__rdiv__(y) <==> y/x
__rdivmod__(...)
x.__rdivmod__(y) <==> divmod(y, x)
__reduce__(...)
__rfloordiv__(...)
x.__rfloordiv__(y) <==> y//x
__rlshift__(...)
x.__rlshift__(y) <==> y<<x
__rmod__(...)
x.__rmod__(y) <==> y%x
__rmul__(...)
x.__rmul__(y) <==> y*x
__ror__(...)
x.__ror__(y) <==> y|x
__rpow__(...)
y.__rpow__(x[, z]) <==> pow(x, y[, z])
__rrshift__(...)
x.__rrshift__(y) <==> y>>x
__rshift__(...)
x.__rshift__(y) <==> x>>y
__rsub__(...)
x.__rsub__(y) <==> y-x
__rtruediv__(...)
x.__rtruediv__(y) <==> y/x
__rxor__(...)
x.__rxor__(y) <==> y^x
__setstate__(...)
__sub__(...)
x.__sub__(y) <==> x-y
__truediv__(...)
x.__truediv__(y) <==> x/y
__xor__(...)
x.__xor__(y) <==> x^y
all(...)
any(...)
argmax(...)
argmin(...)
argsort(...)
astype(...)
byteswap(...)
choose(...)
clip(...)
compress(...)
conj(...)
conjugate(...)
copy(...)
cumprod(...)
cumsum(...)
diagonal(...)
dump(...)
dumps(...)
fill(...)
flatten(...)
getfield(...)
item(...)
itemset(...)
max(...)
mean(...)
min(...)
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:
 
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
 
Parameters
----------
new_order : string, 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(...)
prod(...)
ptp(...)
put(...)
ravel(...)
repeat(...)
reshape(...)
resize(...)
round(...)
searchsorted(...)
setfield(...)
setflags(...)
sort(...)
squeeze(...)
std(...)
sum(...)
swapaxes(...)
take(...)
tofile(...)
tolist(...)
tostring(...)
trace(...)
transpose(...)
var(...)
view(...)

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

 
longlong = class int64(signedinteger, int)
    
Method resolution order:
int64
signedinteger
integer
number
generic
int
object

Methods defined here:
__eq__(...)
x.__eq__(y) <==> x==y
__ge__(...)
x.__ge__(y) <==> x>=y
__gt__(...)
x.__gt__(y) <==> x>y
__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 at 0x7f8ebc33ae80>
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
__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__(...)
__str__(...)
x.__str__() <==> str(x)
__sub__(...)
x.__sub__(y) <==> x-y
__truediv__(...)
x.__truediv__(y) <==> x/y
__xor__(...)
x.__xor__(y) <==> x^y
all(...)
any(...)
argmax(...)
argmin(...)
argsort(...)
astype(...)
byteswap(...)
choose(...)
clip(...)
compress(...)
conj(...)
conjugate(...)
copy(...)
cumprod(...)
cumsum(...)
diagonal(...)
dump(...)
dumps(...)
fill(...)
flatten(...)
getfield(...)
item(...)
itemset(...)
max(...)
mean(...)
min(...)
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:
 
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
 
Parameters
----------
new_order : string, 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(...)
prod(...)
ptp(...)
put(...)
ravel(...)
repeat(...)
reshape(...)
resize(...)
round(...)
searchsorted(...)
setfield(...)
setflags(...)
sort(...)
squeeze(...)
std(...)
sum(...)
swapaxes(...)
take(...)
tofile(...)
tolist(...)
tostring(...)
trace(...)
transpose(...)
var(...)
view(...)

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

Methods inherited from int:
__cmp__(...)
x.__cmp__(y) <==> cmp(x,y)
__coerce__(...)
x.__coerce__(y) <==> coerce(x, y)
__format__(...)
__getattribute__(...)
x.__getattribute__('name') <==> x.name
__getnewargs__(...)
__hash__(...)
x.__hash__() <==> hash(x)
__trunc__(...)
Truncating an Integral returns itself.

Data descriptors inherited from int:
denominator
the denominator of a rational number in lowest terms
numerator
the numerator of a rational number in lowest terms

 
class ndarray(object)
    ndarray(shape, dtype=float, buffer=None, offset=0,
        strides=None, order=None)
 
An array object represents a multidimensional, homogeneous array
of fixed-size items.  An associated data-type object
describes the format of each element in the array (its byte-order,
how many bytes it occupies in memory, whether it is an integer or
floating point number, etc.).
 
Arrays should be constructed using `array`, `zeros` or `empty` (refer to
the ``See Also`` section below).  The parameters given here describe
a low-level method for instantiating an array (`ndarray(...)`).
 
For more information, refer to the `numpy` module and examine the
the methods and attributes of an array.
 
Attributes
----------
T : ndarray
    Transponent of the array.
data : buffer
    Array data in memory.
dtype : data type
    Data type, describing the format of the elements in the array.
flags : dict
    Dictionary containing information related to memory use, e.g.,
    'C_CONTIGUOUS', 'OWNDATA', 'WRITEABLE', and others.
flat : ndarray
    Return flattened version of the array as an iterator.  The iterator
    allows assignments, e.g., ``x.flat = 3``.
imag : ndarray
    Imaginary part of the array.
real : ndarray
    Real part of the array.
size : int
    Number of elements in the array.
itemsize : int
    The size of each element in memory (in bytes).
nbytes : int
    The total number of bytes required to store the array data,
    i.e., ``itemsize * size``.
ndim : int
    The number of dimensions that the array has.
shape : tuple of ints
    Shape of the array.
strides : tuple of ints
    The step-size required to move from one element to the next in memory.
    For example, a contiguous ``(3, 4)`` array of type ``int16`` in C-order
    has strides ``(8, 2)``.  This implies that to move from element to
    element in memory requires jumps of 2 bytes.  To move from row-to-row,
    one needs to jump 6 bytes at a time (``2 * 4``).
ctypes : ctypes object
    Class containing properties of the array needed for interaction
    with ctypes.
base : ndarray
    If the array is a view on another array, that array is
    its `base` (unless that array is also a view).  The `base` array
    is where the array data is ultimately stored.
 
Parameters
----------
shape : tuple of ints
    Shape of created array.
dtype : data type, optional
    Any object that can be interpreted a numpy data type.
buffer : object exposing buffer interface, optional
    Used to fill the array with data.
offset : int, optional
    Offset of array data in buffer.
strides : tuple of ints, optional
    Strides of data in memory.
order : {'C', 'F'}, optional
    Row-major or column-major order.
 
See Also
--------
array : Construct an array.
zeros : Create an array and fill its allocated memory with zeros.
empty : Create an array, but leave its allocated memory unchanged.
dtype : Create a data type.
 
Notes
-----
There are two modes of creating an array using __new__:
 
1. If `buffer` is None, then only `shape`, `dtype`, and `order`
   are used.
2. If `buffer` is an object exporting the buffer interface, then
   all keywords are interpreted.
 
No __init__ method is needed because the array is fully initialized
after the __new__ method.
 
Examples
--------
These examples illustrate the low-level `ndarray` constructor.  Refer
to the `See Also` section for easier ways of constructing an ndarray.
 
First mode, `buffer` is None:
 
>>> np.ndarray(shape=(2,2), dtype=float, order='F')
array([[ -1.13698227e+002,   4.25087011e-303],
       [  2.88528414e-306,   3.27025015e-309]])
 
Second mode:
 
>>> np.ndarray((2,), buffer=np.array([1,2,3]),
...            offset=np.int_().itemsize,
...            dtype=int) # offset = 1*itemsize, i.e. skip first element
array([2, 3])
 
  Methods defined here:
__abs__(...)
x.__abs__() <==> abs(x)
__add__(...)
x.__add__(y) <==> x+y
__and__(...)
x.__and__(y) <==> x&y
__array__(...)
a.__array__(|dtype) -> reference if type unchanged, copy otherwise.
 
Returns either a new reference to self if dtype is not given or a new array
of provided data type if dtype is different from the current dtype of the
array.
__array_wrap__(...)
a.__array_wrap__(obj) -> Object of same type as a from ndarray obj.
__contains__(...)
x.__contains__(y) <==> y in x
__copy__(...)
a.__copy__([order])
 
Return a copy of the array.
 
Parameters
----------
order : {'C', 'F', 'A'}, optional
    If order is 'C' (False) then the result is contiguous (default).
    If order is 'Fortran' (True) then the result has fortran order.
    If order is 'Any' (None) then the result has fortran order
    only if the array already is in fortran order.
__deepcopy__(...)
a.__deepcopy__() -> Deep copy of array.
 
Used if copy.deepcopy is called on an array.
__delitem__(...)
x.__delitem__(y) <==> del x[y]
__delslice__(...)
x.__delslice__(i, j) <==> del x[i:j]
 
Use of negative indices is not supported.
__div__(...)
x.__div__(y) <==> x/y
__divmod__(...)
x.__divmod__(y) <==> divmod(x, y)
__eq__(...)
x.__eq__(y) <==> x==y
__float__(...)
x.__float__() <==> float(x)
__floordiv__(...)
x.__floordiv__(y) <==> x//y
__ge__(...)
x.__ge__(y) <==> x>=y
__getitem__(...)
x.__getitem__(y) <==> x[y]
__getslice__(...)
x.__getslice__(i, j) <==> x[i:j]
 
Use of negative indices is not supported.
__gt__(...)
x.__gt__(y) <==> x>y
__hex__(...)
x.__hex__() <==> hex(x)
__iadd__(...)
x.__iadd__(y) <==> x+y
__iand__(...)
x.__iand__(y) <==> x&y
__idiv__(...)
x.__idiv__(y) <==> x/y
__ifloordiv__(...)
x.__ifloordiv__(y) <==> x//y
__ilshift__(...)
x.__ilshift__(y) <==> x<<y
__imod__(...)
x.__imod__(y) <==> x%y
__imul__(...)
x.__imul__(y) <==> x*y
__index__(...)
x[y:z] <==> x[y.__index__():z.__index__()]
__int__(...)
x.__int__() <==> int(x)
__invert__(...)
x.__invert__() <==> ~x
__ior__(...)
x.__ior__(y) <==> x|y
__ipow__(...)
x.__ipow__(y) <==> x**y
__irshift__(...)
x.__irshift__(y) <==> x>>y
__isub__(...)
x.__isub__(y) <==> x-y
__iter__(...)
x.__iter__() <==> iter(x)
__itruediv__(...)
x.__itruediv__(y) <==> x/y
__ixor__(...)
x.__ixor__(y) <==> x^y
__le__(...)
x.__le__(y) <==> x<=y
__len__(...)
x.__len__() <==> len(x)
__long__(...)
x.__long__() <==> long(x)
__lshift__(...)
x.__lshift__(y) <==> x<<y
__lt__(...)
x.__lt__(y) <==> x<y
__mod__(...)
x.__mod__(y) <==> x%y
__mul__(...)
x.__mul__(y) <==> x*y
__ne__(...)
x.__ne__(y) <==> x!=y
__neg__(...)
x.__neg__() <==> -x
__nonzero__(...)
x.__nonzero__() <==> x != 0
__oct__(...)
x.__oct__() <==> oct(x)
__or__(...)
x.__or__(y) <==> x|y
__pos__(...)
x.__pos__() <==> +x
__pow__(...)
x.__pow__(y[, z]) <==> pow(x, y[, z])
__radd__(...)
x.__radd__(y) <==> y+x
__rand__(...)
x.__rand__(y) <==> y&x
__rdiv__(...)
x.__rdiv__(y) <==> y/x
__rdivmod__(...)
x.__rdivmod__(y) <==> divmod(y, x)
__reduce__(...)
a.__reduce__()
 
For pickling.
__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
__setitem__(...)
x.__setitem__(i, y) <==> x[i]=y
__setslice__(...)
x.__setslice__(i, j, y) <==> x[i:j]=y
 
Use  of negative indices is not supported.
__setstate__(...)
a.__setstate__(version, shape, dtype, isfortran, rawdata)
 
For unpickling.
 
Parameters
----------
version : int
    optional pickle version. If omitted defaults to 0.
shape : tuple
dtype : data-type
isFortran : bool
rawdata : string or list
    a binary string with the data (or a list if 'a' is an object array)
__str__(...)
x.__str__() <==> str(x)
__sub__(...)
x.__sub__(y) <==> x-y
__truediv__(...)
x.__truediv__(y) <==> x/y
__xor__(...)
x.__xor__(y) <==> x^y
all(...)
a.all(axis=None, out=None)
 
Returns True if all elements evaluate to True.
 
Refer to `numpy.all` for full documentation.
 
See Also
--------
numpy.all : equivalent function
any(...)
a.any(axis=None, out=None)
 
Check if any of the elements of `a` are true.
 
Refer to `numpy.any` for full documentation.
 
See Also
--------
numpy.any : equivalent function
argmax(...)
a.argmax(axis=None, out=None)
 
Return indices of the maximum values along the given axis of `a`.
 
Parameters
----------
axis : int, optional
    Axis along which to operate.  By default flattened input is used.
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.
 
Returns
-------
index_array : ndarray
    An array of indices or single index value, or a reference to `out`
    if it was specified.
 
Examples
--------
>>> a = np.arange(6).reshape(2,3)
>>> a.argmax()
5
>>> a.argmax(0)
array([1, 1, 1])
>>> a.argmax(1)
array([2, 2])
argmin(...)
a.argmin(axis=None, out=None)
 
Return indices of the minimum values along the given axis of `a`.
 
Refer to `numpy.ndarray.argmax` for detailed documentation.
argsort(...)
a.argsort(axis=-1, kind='quicksort', order=None)
 
Returns the indices that would sort this array.
 
Refer to `numpy.argsort` for full documentation.
 
See Also
--------
numpy.argsort : equivalent function
astype(...)
a.astype(t)
 
Copy of the array, cast to a specified type.
 
Parameters
----------
t : string or dtype
    Typecode or data-type to which the array is cast.
 
Examples
--------
>>> x = np.array([1, 2, 2.5])
>>> x
array([ 1. ,  2. ,  2.5])
 
>>> x.astype(int)
array([1, 2, 2])
byteswap(...)
a.byteswap(inplace)
 
Swap the bytes of the array elements
 
Toggle between low-endian and big-endian data representation by
returning a byteswapped array, optionally swapped in-place.
 
Parameters
----------
inplace: bool, optional
    If ``True``, swap bytes in-place, default is ``False``.
 
Returns
-------
out: ndarray
    The byteswapped array. If `inplace` is ``True``, this is
    a view to self.
 
Examples
--------
>>> A = np.array([1, 256, 8755], dtype=np.int16)
>>> map(hex, A)
['0x1', '0x100', '0x2233']
>>> A.byteswap(True)
array([  256,     1, 13090], dtype=int16)
>>> map(hex, A)
['0x100', '0x1', '0x3322']
 
Arrays of strings are not swapped
 
>>> A = np.array(['ceg', 'fac'])
>>> A.byteswap()
array(['ceg', 'fac'],
      dtype='|S3')
choose(...)
a.choose(choices, out=None, mode='raise')
 
Use an index array to construct a new array from a set of choices.
 
Refer to `numpy.choose` for full documentation.
 
See Also
--------
numpy.choose : equivalent function
clip(...)
a.clip(a_min, a_max, out=None)
 
Return an array whose values are limited to ``[a_min, a_max]``.
 
Refer to `numpy.clip` for full documentation.
 
See Also
--------
numpy.clip : equivalent function
compress(...)
a.compress(condition, axis=None, out=None)
 
Return selected slices of this array along given axis.
 
Refer to `numpy.compress` for full documentation.
 
See Also
--------
numpy.compress : equivalent function
conj(...)
a.conj()
 
Return an array with all complex-valued elements conjugated.
conjugate(...)
a.conjugate()
 
Return an array with all complex-valued elements conjugated.
copy(...)
a.copy(order='C')
 
Return a copy of the array.
 
Parameters
----------
order : {'C', 'F', 'A'}, optional
    By default, the result is stored in C-contiguous (row-major) order in
    memory.  If `order` is `F`, the result has 'Fortran' (column-major)
    order.  If order is 'A' ('Any'), then the result has the same order
    as the input.
 
Examples
--------
>>> x = np.array([[1,2,3],[4,5,6]], order='F')
 
>>> y = x.copy()
 
>>> x.fill(0)
 
>>> x
array([[0, 0, 0],
       [0, 0, 0]])
 
>>> y
array([[1, 2, 3],
       [4, 5, 6]])
 
>>> y.flags['C_CONTIGUOUS']
True
cumprod(...)
a.cumprod(axis=None, dtype=None, out=None)
 
Return the cumulative product of the elements along the given axis.
 
Refer to `numpy.cumprod` for full documentation.
 
See Also
--------
numpy.cumprod : equivalent function
cumsum(...)
a.cumsum(axis=None, dtype=None, out=None)
 
Return the cumulative sum of the elements along the given axis.
 
Refer to `numpy.cumsum` for full documentation.
 
See Also
--------
numpy.cumsum : equivalent function
diagonal(...)
a.diagonal(offset=0, axis1=0, axis2=1)
 
Return specified diagonals.
 
Refer to `numpy.diagonal` for full documentation.
 
See Also
--------
numpy.diagonal : equivalent function
dump(...)
a.dump(file)
 
Dump a pickle of the array to the specified file.
The array can be read back with pickle.load or numpy.load.
 
Parameters
----------
file : str
    A string naming the dump file.
dumps(...)
a.dumps()
 
Returns the pickle of the array as a string.
pickle.loads or numpy.loads will convert the string back to an array.
fill(...)
a.fill(value)
 
Fill the array with a scalar value.
 
Parameters
----------
a : ndarray
    Input array
value : scalar
    All elements of `a` will be assigned this value.
 
Examples
--------
>>> a = np.array([1, 2])
>>> a.fill(0)
>>> a
array([0, 0])
>>> a = np.empty(2)
>>> a.fill(1)
>>> a
array([ 1.,  1.])
flatten(...)
a.flatten(order='C')
 
Return a copy of the array collapsed into one dimension.
 
Parameters
----------
order : {'C', 'F'}, optional
    Whether to flatten in C (row-major) or Fortran (column-major) order.
    The default is 'C'.
 
Returns
-------
y : ndarray
    A copy of the input array, flattened to one dimension.
 
See Also
--------
ravel : Return a flattened array.
flat : A 1-D flat iterator over the array.
 
Examples
--------
>>> a = np.array([[1,2], [3,4]])
>>> a.flatten()
array([1, 2, 3, 4])
>>> a.flatten('F')
array([1, 3, 2, 4])
getfield(...)
a.getfield(dtype, offset)
 
Returns a field of the given array as a certain type. A field is a view of
the array data with each itemsize determined by the given type and the
offset into the current array.
item(...)
a.item()
 
Copy the first element of array to a standard Python scalar and return
it. The array must be of size one.
itemset(...)
max(...)
a.max(axis=None, out=None)
 
Return the maximum along a given axis.
 
Refer to `numpy.amax` for full documentation.
 
See Also
--------
numpy.amax : equivalent function
mean(...)
a.mean(axis=None, dtype=None, out=None)
 
Returns the average of the array elements along given axis.
 
Refer to `numpy.mean` for full documentation.
 
See Also
--------
numpy.mean : equivalent function
min(...)
a.min(axis=None, out=None)
 
Return the minimum along a given axis.
 
Refer to `numpy.amin` for full documentation.
 
See Also
--------
numpy.amin : equivalent function
newbyteorder(...)
arr.newbyteorder(new_order='S')
 
Return the array with the same data viewed with a different byte order.
 
Equivalent to::
 
    arr.view(arr.dtype.newbytorder(new_order))
 
Changes are also made in all fields and sub-arrays of the array data
type.
 
 
 
Parameters
----------
new_order : string, optional
    Byte order to force; a value from the byte order specifications
    above. `new_order` codes can be any of::
 
     * 'S' - swap dtype from current to opposite endian
     * {'<', 'L'} - little endian
     * {'>', 'B'} - big endian
     * {'=', 'N'} - native order
     * {'|', 'I'} - ignore (no change to byte order)
 
    The default value ('S') results in swapping the current
    byte order. The code does a case-insensitive check on the first
    letter of `new_order` for the alternatives above.  For example,
    any of 'B' or 'b' or 'biggish' are valid to specify big-endian.
 
 
Returns
-------
new_arr : array
    New array object with the dtype reflecting given change to the
    byte order.
nonzero(...)
a.nonzero()
 
Return the indices of the elements that are non-zero.
 
Refer to `numpy.nonzero` for full documentation.
 
See Also
--------
numpy.nonzero : equivalent function
prod(...)
a.prod(axis=None, dtype=None, out=None)
 
Return the product of the array elements over the given axis
 
Refer to `numpy.prod` for full documentation.
 
See Also
--------
numpy.prod : equivalent function
ptp(...)
a.ptp(axis=None, out=None)
 
Peak to peak (maximum - minimum) value along a given axis.
 
Refer to `numpy.ptp` for full documentation.
 
See Also
--------
numpy.ptp : equivalent function
put(...)
a.put(indices, values, mode='raise')
 
Set a.flat[n] = values[n] for all n in indices.
 
Refer to `numpy.put` for full documentation.
 
See Also
--------
numpy.put : equivalent function
ravel(...)
a.ravel([order])
 
Return a flattened array.
 
Refer to `numpy.ravel` for full documentation.
 
See Also
--------
numpy.ravel : equivalent function
 
ndarray.flat : a flat iterator on the array.
repeat(...)
a.repeat(repeats, axis=None)
 
Repeat elements of an array.
 
Refer to `numpy.repeat` for full documentation.
 
See Also
--------
numpy.repeat : equivalent function
reshape(...)
a.reshape(shape, order='C')
 
Returns an array containing the same data with a new shape.
 
Refer to `numpy.reshape` for full documentation.
 
See Also
--------
numpy.reshape : equivalent function
resize(...)
a.resize(new_shape, refcheck=True, order=False)
 
Change shape and size of array in-place.
 
Parameters
----------
a : ndarray
    Input array.
new_shape : {tuple, int}
    Shape of resized array.
refcheck : bool, optional
    If False, memory referencing will not be checked. Default is True.
order : bool, optional
    <needs an explanation>. Default if False.
 
Returns
-------
None
 
Raises
------
ValueError
    If `a` does not own its own data, or references or views to it exist.
 
Examples
--------
Shrinking an array: array is flattened in C-order, resized, and reshaped:
 
>>> a = np.array([[0,1],[2,3]])
>>> a.resize((2,1))
>>> a
array([[0],
       [1]])
 
Enlarging an array: as above, but missing entries are filled with zeros:
 
>>> b = np.array([[0,1],[2,3]])
>>> b.resize((2,3))
>>> b
array([[0, 1, 2],
       [3, 0, 0]])
 
Referencing an array prevents resizing:
 
>>> c = a
>>> a.resize((1,1))
Traceback (most recent call last):
...
ValueError: cannot resize an array that has been referenced ...
round(...)
a.round(decimals=0, out=None)
 
Return an array rounded a to the given number of decimals.
 
Refer to `numpy.around` for full documentation.
 
See Also
--------
numpy.around : equivalent function
searchsorted(...)
a.searchsorted(v, side='left')
 
Find indices where elements of v should be inserted in a to maintain order.
 
For full documentation, see `numpy.searchsorted`
 
See Also
--------
numpy.searchsorted : equivalent function
setfield(...)
m.setfield(value, dtype, offset) -> None.
places val into field of the given array defined by the data type and offset.
setflags(...)
a.setflags(write=None, align=None, uic=None)
sort(...)
a.sort(axis=-1, kind='quicksort', order=None)
 
Sort an array, in-place.
 
Parameters
----------
axis : int, optional
    Axis along which to sort. Default is -1, which means sort along the
    last axis.
kind : {'quicksort', 'mergesort', 'heapsort'}, optional
    Sorting algorithm. Default is 'quicksort'.
order : list, optional
    When `a` is an array with fields defined, this argument specifies
    which fields to compare first, second, etc.  Not all fields need be
    specified.
 
See Also
--------
numpy.sort : Return a sorted copy of an array.
argsort : Indirect sort.
lexsort : Indirect stable sort on multiple keys.
searchsorted : Find elements in sorted array.
 
Notes
-----
See ``sort`` for notes on the different sorting algorithms.
 
Examples
--------
>>> a = np.array([[1,4], [3,1]])
>>> a.sort(axis=1)
>>> a
array([[1, 4],
       [1, 3]])
>>> a.sort(axis=0)
>>> a
array([[1, 3],
       [1, 4]])
 
Use the `order` keyword to specify a field to use when sorting a
structured array:
 
>>> a = np.array([('a', 2), ('c', 1)], dtype=[('x', 'S1'), ('y', int)])
>>> a.sort(order='y')
>>> a
array([('c', 1), ('a', 2)],
      dtype=[('x', '|S1'), ('y', '<i4')])
squeeze(...)
a.squeeze()
 
Remove single-dimensional entries from the shape of `a`.
 
Refer to `numpy.squeeze` for full documentation.
 
See Also
--------
numpy.squeeze : equivalent function
std(...)
a.std(axis=None, dtype=None, out=None, ddof=0)
 
Returns the standard deviation of the array elements along given axis.
 
Refer to `numpy.std` for full documentation.
 
See Also
--------
numpy.std : equivalent function
sum(...)
a.sum(axis=None, dtype=None, out=None)
 
Return the sum of the array elements over the given axis.
 
Refer to `numpy.sum` for full documentation.
 
See Also
--------
numpy.sum : equivalent function
swapaxes(...)
a.swapaxes(axis1, axis2)
 
Return a view of the array with `axis1` and `axis2` interchanged.
 
Refer to `numpy.swapaxes` for full documentation.
 
See Also
--------
numpy.swapaxes : equivalent function
take(...)
a.take(indices, axis=None, out=None, mode='raise')
 
Return an array formed from the elements of a at the given indices.
 
Refer to `numpy.take` for full documentation.
 
See Also
--------
numpy.take : equivalent function
tofile(...)
a.tofile(fid, sep="", format="%s")
 
Write array to a file as text or binary.
 
Data is always written in 'C' order, independently of the order of `a`.
The data produced by this method can be recovered by using the function
fromfile().
 
This is a convenience function for quick storage of array data.
Information on endianess and precision is lost, so this method is not a
good choice for files intended to archive data or transport data between
machines with different endianess. Some of these problems can be overcome
by outputting the data as text files at the expense of speed and file size.
 
Parameters
----------
fid : file or string
    An open file object or a string containing a filename.
sep : string
    Separator between array items for text output.
    If "" (empty), a binary file is written, equivalently to
    file.write(a.tostring()).
format : string
    Format string for text file output.
    Each entry in the array is formatted to text by converting it to the
    closest Python type, and using "format" % item.
tolist(...)
a.tolist()
 
Return the array as a possibly nested list.
 
Return a copy of the array data as a (nested) Python list.
Data items are converted to the nearest compatible Python type.
 
Parameters
----------
none
 
Returns
-------
y : list
    The possibly nested list of array elements.
 
Notes
-----
The array may be recreated, ``a = np.array(a.tolist())``.
 
Examples
--------
>>> a = np.array([1, 2])
>>> a.tolist()
[1, 2]
>>> a = np.array([[1, 2], [3, 4]])
>>> list(a)
[array([1, 2]), array([3, 4])]
>>> a.tolist()
[[1, 2], [3, 4]]
tostring(...)
a.tostring(order='C')
 
Construct a Python string containing the raw data bytes in the array.
 
Parameters
----------
order : {'C', 'F', None}
    Order of the data for multidimensional arrays:
    C, Fortran, or the same as for the original array.
trace(...)
a.trace(offset=0, axis1=0, axis2=1, dtype=None, out=None)
 
Return the sum along diagonals of the array.
 
Refer to `numpy.trace` for full documentation.
 
See Also
--------
numpy.trace : equivalent function
transpose(...)
a.transpose(*axes)
 
Returns a view of 'a' with axes transposed. If no axes are given,
or None is passed, switches the order of the axes. For a 2-d
array, this is the usual matrix transpose. If axes are given,
they describe how the axes are permuted.
 
See Also
--------
ndarray.T : array property returning the array transposed
 
 
Examples
--------
>>> a = np.array([[1,2],[3,4]])
>>> a
array([[1, 2],
       [3, 4]])
>>> a.transpose()
array([[1, 3],
       [2, 4]])
>>> a.transpose((1,0))
array([[1, 3],
       [2, 4]])
>>> a.transpose(1,0)
array([[1, 3],
       [2, 4]])
var(...)
a.var(axis=None, dtype=None, out=None, ddof=0)
 
Returns the variance of the array elements, along given axis.
 
Refer to `numpy.var` for full documentation.
 
See Also
--------
numpy.var : equivalent function
view(...)
a.view(dtype=None, type=None)
 
New view of array with the same data.
 
Parameters
----------
dtype : data-type
    Data-type descriptor of the returned view, e.g. float32 or int16.
type : python type
    Type of the returned view, e.g. ndarray or matrix.
 
Examples
--------
>>> x = np.array([(1, 2)], dtype=[('a', np.int8), ('b', np.int8)])
 
Viewing array data using a different type and dtype:
 
>>> y = x.view(dtype=np.int16, type=np.matrix)
>>> print y.dtype
int16
 
>>> print type(y)
<class 'numpy.core.defmatrix.matrix'>
 
Using a view to convert an array to a record array:
 
>>> z = x.view(np.recarray)
>>> z.a
array([1], dtype=int8)
 
Views share data:
 
>>> x[0] = (9, 10)
>>> z[0]
(9, 10)

Data descriptors defined here:
T
Same as transpose() except self is returned for self.ndim < 2.
 
Examples
--------
>>> x = np.array([[1.,2.],[3.,4.]])
>>> x.T
array([[ 1.,  3.],
       [ 2.,  4.]])
__array_finalize__
None.
__array_interface__
Array protocol: Python side.
__array_priority__
Array priority.
__array_struct__
Array protocol: C-struct side.
base
Base object if memory is from some other object.
 
Examples
--------
 
Base of an array owning its memory is None:
 
>>> x = np.array([1,2,3,4])
>>> x.base is None
True
 
Slicing creates a view, and the memory is shared with x:
 
>>> y = x[2:]
>>> y.base is x
True
ctypes
A ctypes interface object.
data
Buffer object pointing to the start of the data.
dtype
Data-type for the array.
flags
Information about the memory layout of the array.
 
Attributes
----------
C_CONTIGUOUS (C)
    The data is in a single, C-style contiguous segment.
F_CONTIGUOUS (F)
    The data is in a single, Fortran-style contiguous segment.
OWNDATA (O)
    The array owns the memory it uses or borrows it from another object.
WRITEABLE (W)
    The data area can be written to.
ALIGNED (A)
    The data and strides are aligned appropriately for the hardware.
UPDATEIFCOPY (U)
    This array is a copy of some other array. When this array is
    deallocated, the base array will be updated with the contents of
    this array.
 
FNC
    F_CONTIGUOUS and not C_CONTIGUOUS.
FORC
    F_CONTIGUOUS or C_CONTIGUOUS (one-segment test).
BEHAVED (B)
    ALIGNED and WRITEABLE.
CARRAY (CA)
    BEHAVED and C_CONTIGUOUS.
FARRAY (FA)
    BEHAVED and F_CONTIGUOUS and not C_CONTIGUOUS.
 
Notes
-----
The `flags` object can be also accessed dictionary-like, and using
lowercased attribute names. Short flag names are only supported in
dictionary access.
 
Only the UPDATEIFCOPY, WRITEABLE, and ALIGNED flags can be changed by
the user, via assigning to ``flags['FLAGNAME']`` or `ndarray.setflags`.
The array flags cannot be set arbitrarily:
 
- UPDATEIFCOPY can only be set ``False``.
- ALIGNED can only be set ``True`` if the data is truly aligned.
- WRITEABLE can only be set ``True`` if the array owns its own memory
  or the ultimate owner of the memory exposes a writeable buffer
  interface or is a string.
flat
A 1-D flat iterator over the array.
 
This is a `flatiter` instance, which acts similarly to a Python iterator.
 
See Also
--------
flatten : Return a copy of the array collapsed into one dimension.
flatiter
 
Examples
--------
>>> x = np.arange(1, 7).reshape(2, 3)
>>> x
array([[1, 2, 3],
       [4, 5, 6]])
>>> x.flat[3]
4
>>> x.T
array([[1, 4],
       [2, 5],
       [3, 6]])
>>> x.T.flat[3]
5
 
>>> type(x.flat)
<type 'numpy.flatiter'>
imag
The imaginary part of the array.
 
Examples
--------
>>> x = np.sqrt([1+0j, 0+1j])
>>> x.imag
array([ 0.        ,  0.70710678])
>>> x.imag.dtype
dtype('float64')
itemsize
Length of one element in bytes.
 
Examples
--------
>>> x = np.array([1,2,3], dtype=np.float64)
>>> x.itemsize
8
>>> x = np.array([1,2,3], dtype=np.complex128)
>>> x.itemsize
16
nbytes
Number of bytes in the array.
 
Examples
--------
>>> x = np.zeros((3,5,2), dtype=np.complex128)
>>> x.nbytes
480
>>> np.prod(x.shape) * x.itemsize
480
ndim
Number of array dimensions.
 
Examples
--------
 
>>> x = np.array([1,2,3])
>>> x.ndim
1
>>> y = np.zeros((2,3,4))
>>> y.ndim
3
real
The real part of the array.
 
Examples
--------
>>> x = np.sqrt([1+0j, 0+1j])
>>> x.real
array([ 1.        ,  0.70710678])
>>> x.real.dtype
dtype('float64')
 
See Also
--------
numpy.real : equivalent function
shape
Tuple of array dimensions.
 
Examples
--------
>>> x = np.array([1,2,3,4])
>>> x.shape
(4,)
>>> y = np.zeros((4,5,6))
>>> y.shape
(4, 5, 6)
>>> y.shape = (2, 5, 2, 3, 2)
>>> y.shape
(2, 5, 2, 3, 2)
size
Number of elements in the array.
 
Examples
--------
>>> x = np.zeros((3,5,2), dtype=np.complex128)
>>> x.size
30
strides
Tuple of bytes to step in each dimension.
 
The byte offset of element ``(i[0], i[1], ..., i[n])`` in an array `a`
is::
 
    offset = sum(np.array(i) * a.strides)
 
Examples
--------
>>> x = np.reshape(np.arange(5*6*7*8), (5,6,7,8)).transpose(2,3,1,0)
>>> x.strides
(32, 4, 224, 1344)
>>> i = np.array([3,5,2,2])
>>> offset = sum(i * x.strides)
>>> x[3,5,2,2]
813
>>> offset / x.itemsize
813

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

 
class number(generic)
    
Method resolution order:
number
generic
object

Methods inherited from generic:
__abs__(...)
x.__abs__() <==> abs(x)
__add__(...)
x.__add__(y) <==> x+y
__and__(...)
x.__and__(y) <==> x&y
__array__(...)
sc.__array__(|type) return 0-dim array
__array_wrap__(...)
sc.__array_wrap__(obj) return scalar from array
__copy__(...)
__deepcopy__(...)
__div__(...)
x.__div__(y) <==> x/y
__divmod__(...)
x.__divmod__(y) <==> divmod(x, y)
__eq__(...)
x.__eq__(y) <==> x==y
__float__(...)
x.__float__() <==> float(x)
__floordiv__(...)
x.__floordiv__(y) <==> x//y
__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__(...)
__str__(...)
x.__str__() <==> str(x)
__sub__(...)
x.__sub__(y) <==> x-y
__truediv__(...)
x.__truediv__(y) <==> x/y
__xor__(...)
x.__xor__(y) <==> x^y
all(...)
any(...)
argmax(...)
argmin(...)
argsort(...)
astype(...)
byteswap(...)
choose(...)
clip(...)
compress(...)
conj(...)
conjugate(...)
copy(...)
cumprod(...)
cumsum(...)
diagonal(...)
dump(...)
dumps(...)
fill(...)
flatten(...)
getfield(...)
item(...)
itemset(...)
max(...)
mean(...)
min(...)
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:
 
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
 
Parameters
----------
new_order : string, 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(...)
prod(...)
ptp(...)
put(...)
ravel(...)
repeat(...)
reshape(...)
resize(...)
round(...)
searchsorted(...)
setfield(...)
setflags(...)
sort(...)
squeeze(...)
std(...)
sum(...)
swapaxes(...)
take(...)
tofile(...)
tolist(...)
tostring(...)
trace(...)
transpose(...)
var(...)
view(...)

Data descriptors inherited from generic:
T
transpose
__array_interface__
Array protocol: Python side
__array_priority__
Array priority.
__array_struct__
Array protocol: struct
base
base object
data
pointer to start of data
dtype
get array data-descriptor
flags
integer value of flags
flat
a 1-d view of scalar
imag
imaginary part of scalar
itemsize
length of one element in bytes
nbytes
length of item in bytes
ndim
number of array dimensions
real
real part of scalar
shape
tuple of array dimensions
size
number of elements in the gentype
strides
tuple of bytes steps in each dimension

 
object0 = class object_(generic)
    
Method resolution order:
object_
generic
object

Methods defined here:
__add__(...)
x.__add__(y) <==> x+y
__call__(...)
x.__call__(...) <==> x(...)
__contains__(...)
x.__contains__(y) <==> y in x
__delattr__(...)
x.__delattr__('name') <==> del x.name
__delitem__(...)
x.__delitem__(y) <==> del x[y]
__eq__(...)
x.__eq__(y) <==> x==y
__ge__(...)
x.__ge__(y) <==> x>=y
__getattribute__(...)
x.__getattribute__('name') <==> x.name
__getitem__(...)
x.__getitem__(y) <==> x[y]
__gt__(...)
x.__gt__(y) <==> x>y
__hash__(...)
x.__hash__() <==> hash(x)
__iadd__(...)
x.__iadd__(y) <==> x+=y
__imul__(...)
x.__imul__(y) <==> x*=y
__le__(...)
x.__le__(y) <==> x<=y
__len__(...)
x.__len__() <==> len(x)
__lt__(...)
x.__lt__(y) <==> x<y
__mul__(...)
x.__mul__(n) <==> x*n
__ne__(...)
x.__ne__(y) <==> x!=y
__rmul__(...)
x.__rmul__(n) <==> n*x
__setattr__(...)
x.__setattr__('name', value) <==> x.name = value
__setitem__(...)
x.__setitem__(i, y) <==> x[i]=y

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

Methods inherited from generic:
__abs__(...)
x.__abs__() <==> abs(x)
__and__(...)
x.__and__(y) <==> x&y
__array__(...)
sc.__array__(|type) return 0-dim array
__array_wrap__(...)
sc.__array_wrap__(obj) return scalar from array
__copy__(...)
__deepcopy__(...)
__div__(...)
x.__div__(y) <==> x/y
__divmod__(...)
x.__divmod__(y) <==> divmod(x, y)
__float__(...)
x.__float__() <==> float(x)
__floordiv__(...)
x.__floordiv__(y) <==> x//y
__hex__(...)
x.__hex__() <==> hex(x)
__int__(...)
x.__int__() <==> int(x)
__invert__(...)
x.__invert__() <==> ~x
__long__(...)
x.__long__() <==> long(x)
__lshift__(...)
x.__lshift__(y) <==> x<<y
__mod__(...)
x.__mod__(y) <==> x%y
__neg__(...)
x.__neg__() <==> -x
__nonzero__(...)
x.__nonzero__() <==> x != 0
__oct__(...)
x.__oct__() <==> oct(x)
__or__(...)
x.__or__(y) <==> x|y
__pos__(...)
x.__pos__() <==> +x
__pow__(...)
x.__pow__(y[, z]) <==> pow(x, y[, z])
__radd__(...)
x.__radd__(y) <==> y+x
__rand__(...)
x.__rand__(y) <==> y&x
__rdiv__(...)
x.__rdiv__(y) <==> y/x
__rdivmod__(...)
x.__rdivmod__(y) <==> divmod(y, x)
__reduce__(...)
__repr__(...)
x.__repr__() <==> repr(x)
__rfloordiv__(...)
x.__rfloordiv__(y) <==> y//x
__rlshift__(...)
x.__rlshift__(y) <==> y<<x
__rmod__(...)
x.__rmod__(y) <==> y%x
__ror__(...)
x.__ror__(y) <==> y|x
__rpow__(...)
y.__rpow__(x[, z]) <==> pow(x, y[, z])
__rrshift__(...)
x.__rrshift__(y) <==> y>>x
__rshift__(...)
x.__rshift__(y) <==> x>>y
__rsub__(...)
x.__rsub__(y) <==> y-x
__rtruediv__(...)
x.__rtruediv__(y) <==> y/x
__rxor__(...)
x.__rxor__(y) <==> y^x
__setstate__(...)
__str__(...)
x.__str__() <==> str(x)
__sub__(...)
x.__sub__(y) <==> x-y
__truediv__(...)
x.__truediv__(y) <==> x/y
__xor__(...)
x.__xor__(y) <==> x^y
all(...)
any(...)
argmax(...)
argmin(...)
argsort(...)
astype(...)
byteswap(...)
choose(...)
clip(...)
compress(...)
conj(...)
conjugate(...)
copy(...)
cumprod(...)
cumsum(...)
diagonal(...)
dump(...)
dumps(...)
fill(...)
flatten(...)
getfield(...)
item(...)
itemset(...)
max(...)
mean(...)
min(...)
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:
 
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
 
Parameters
----------
new_order : string, 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(...)
prod(...)
ptp(...)
put(...)
ravel(...)
repeat(...)
reshape(...)
resize(...)
round(...)
searchsorted(...)
setfield(...)
setflags(...)
sort(...)
squeeze(...)
std(...)
sum(...)
swapaxes(...)
take(...)
tofile(...)
tolist(...)
tostring(...)
trace(...)
transpose(...)
var(...)
view(...)

Data descriptors inherited from generic:
T
transpose
__array_interface__
Array protocol: Python side
__array_priority__
Array priority.
__array_struct__
Array protocol: struct
base
base object
data
pointer to start of data
dtype
get array data-descriptor
flags
integer value of flags
flat
a 1-d view of scalar
imag
imaginary part of scalar
itemsize
length of one element in bytes
nbytes
length of item in bytes
ndim
number of array dimensions
real
real part of scalar
shape
tuple of array dimensions
size
number of elements in the gentype
strides
tuple of bytes steps in each dimension

 
class object_(generic)
    
Method resolution order:
object_
generic
object

Methods defined here:
__add__(...)
x.__add__(y) <==> x+y
__call__(...)
x.__call__(...) <==> x(...)
__contains__(...)
x.__contains__(y) <==> y in x
__delattr__(...)
x.__delattr__('name') <==> del x.name
__delitem__(...)
x.__delitem__(y) <==> del x[y]
__eq__(...)
x.__eq__(y) <==> x==y
__ge__(...)
x.__ge__(y) <==> x>=y
__getattribute__(...)
x.__getattribute__('name') <==> x.name
__getitem__(...)
x.__getitem__(y) <==> x[y]
__gt__(...)
x.__gt__(y) <==> x>y
__hash__(...)
x.__hash__() <==> hash(x)
__iadd__(...)
x.__iadd__(y) <==> x+=y
__imul__(...)
x.__imul__(y) <==> x*=y
__le__(...)
x.__le__(y) <==> x<=y
__len__(...)
x.__len__() <==> len(x)
__lt__(...)
x.__lt__(y) <==> x<y
__mul__(...)
x.__mul__(n) <==> x*n
__ne__(...)
x.__ne__(y) <==> x!=y
__rmul__(...)
x.__rmul__(n) <==> n*x
__setattr__(...)
x.__setattr__('name', value) <==> x.name = value
__setitem__(...)
x.__setitem__(i, y) <==> x[i]=y

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

Methods inherited from generic:
__abs__(...)
x.__abs__() <==> abs(x)
__and__(...)
x.__and__(y) <==> x&y
__array__(...)
sc.__array__(|type) return 0-dim array
__array_wrap__(...)
sc.__array_wrap__(obj) return scalar from array
__copy__(...)
__deepcopy__(...)
__div__(...)
x.__div__(y) <==> x/y
__divmod__(...)
x.__divmod__(y) <==> divmod(x, y)
__float__(...)
x.__float__() <==> float(x)
__floordiv__(...)
x.__floordiv__(y) <==> x//y
__hex__(...)
x.__hex__() <==> hex(x)
__int__(...)
x.__int__() <==> int(x)
__invert__(...)
x.__invert__() <==> ~x
__long__(...)
x.__long__() <==> long(x)
__lshift__(...)
x.__lshift__(y) <==> x<<y
__mod__(...)
x.__mod__(y) <==> x%y
__neg__(...)
x.__neg__() <==> -x
__nonzero__(...)
x.__nonzero__() <==> x != 0
__oct__(...)
x.__oct__() <==> oct(x)
__or__(...)
x.__or__(y) <==> x|y
__pos__(...)
x.__pos__() <==> +x
__pow__(...)
x.__pow__(y[, z]) <==> pow(x, y[, z])
__radd__(...)
x.__radd__(y) <==> y+x
__rand__(...)
x.__rand__(y) <==> y&x
__rdiv__(...)
x.__rdiv__(y) <==> y/x
__rdivmod__(...)
x.__rdivmod__(y) <==> divmod(y, x)
__reduce__(...)
__repr__(...)
x.__repr__() <==> repr(x)
__rfloordiv__(...)
x.__rfloordiv__(y) <==> y//x
__rlshift__(...)
x.__rlshift__(y) <==> y<<x
__rmod__(...)
x.__rmod__(y) <==> y%x
__ror__(...)
x.__ror__(y) <==> y|x
__rpow__(...)
y.__rpow__(x[, z]) <==> pow(x, y[, z])
__rrshift__(...)
x.__rrshift__(y) <==> y>>x
__rshift__(...)
x.__rshift__(y) <==> x>>y
__rsub__(...)
x.__rsub__(y) <==> y-x
__rtruediv__(...)
x.__rtruediv__(y) <==> y/x
__rxor__(...)
x.__rxor__(y) <==> y^x
__setstate__(...)
__str__(...)
x.__str__() <==> str(x)
__sub__(...)
x.__sub__(y) <==> x-y
__truediv__(...)
x.__truediv__(y) <==> x/y
__xor__(...)
x.__xor__(y) <==> x^y
all(...)
any(...)
argmax(...)
argmin(...)
argsort(...)
astype(...)
byteswap(...)
choose(...)
clip(...)
compress(...)
conj(...)
conjugate(...)
copy(...)
cumprod(...)
cumsum(...)
diagonal(...)
dump(...)
dumps(...)
fill(...)
flatten(...)
getfield(...)
item(...)
itemset(...)
max(...)
mean(...)
min(...)
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:
 
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
 
Parameters
----------
new_order : string, 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(...)
prod(...)
ptp(...)
put(...)
ravel(...)
repeat(...)
reshape(...)
resize(...)
round(...)
searchsorted(...)
setfield(...)
setflags(...)
sort(...)
squeeze(...)
std(...)
sum(...)
swapaxes(...)
take(...)
tofile(...)
tolist(...)
tostring(...)
trace(...)
transpose(...)
var(...)
view(...)

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

 
short = class int16(signedinteger)
    16-bit integer. Character code ``h``.
 
 
Method resolution order:
int16
signedinteger
integer
number
generic
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 at 0x7f8ebc33a9a0>
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
__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__(...)
__str__(...)
x.__str__() <==> str(x)
__sub__(...)
x.__sub__(y) <==> x-y
__truediv__(...)
x.__truediv__(y) <==> x/y
__xor__(...)
x.__xor__(y) <==> x^y
all(...)
any(...)
argmax(...)
argmin(...)
argsort(...)
astype(...)
byteswap(...)
choose(...)
clip(...)
compress(...)
conj(...)
conjugate(...)
copy(...)
cumprod(...)
cumsum(...)
diagonal(...)
dump(...)
dumps(...)
fill(...)
flatten(...)
getfield(...)
item(...)
itemset(...)
max(...)
mean(...)
min(...)
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:
 
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
 
Parameters
----------
new_order : string, 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(...)
prod(...)
ptp(...)
put(...)
ravel(...)
repeat(...)
reshape(...)
resize(...)
round(...)
searchsorted(...)
setfield(...)
setflags(...)
sort(...)
squeeze(...)
std(...)
sum(...)
swapaxes(...)
take(...)
tofile(...)
tolist(...)
tostring(...)
trace(...)
transpose(...)
var(...)
view(...)

Data descriptors inherited from generic:
T
transpose
__array_interface__
Array protocol: Python side
__array_priority__
Array priority.
__array_struct__
Array protocol: struct
base
base object
data
pointer to start of data
dtype
get array data-descriptor
flags
integer value of flags
flat
a 1-d view of scalar
imag
imaginary part of scalar
itemsize
length of one element in bytes
nbytes
length of item in bytes
ndim
number of array dimensions
real
real part of scalar
shape
tuple of array dimensions
size
number of elements in the gentype
strides
tuple of bytes steps in each dimension

 
class signedinteger(integer)
    
Method resolution order:
signedinteger
integer
number
generic
object

Methods inherited from generic:
__abs__(...)
x.__abs__() <==> abs(x)
__add__(...)
x.__add__(y) <==> x+y
__and__(...)
x.__and__(y) <==> x&y
__array__(...)
sc.__array__(|type) return 0-dim array
__array_wrap__(...)
sc.__array_wrap__(obj) return scalar from array
__copy__(...)
__deepcopy__(...)
__div__(...)
x.__div__(y) <==> x/y
__divmod__(...)
x.__divmod__(y) <==> divmod(x, y)
__eq__(...)
x.__eq__(y) <==> x==y
__float__(...)
x.__float__() <==> float(x)
__floordiv__(...)
x.__floordiv__(y) <==> x//y
__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__(...)
__str__(...)
x.__str__() <==> str(x)
__sub__(...)
x.__sub__(y) <==> x-y
__truediv__(...)
x.__truediv__(y) <==> x/y
__xor__(...)
x.__xor__(y) <==> x^y
all(...)
any(...)
argmax(...)
argmin(...)
argsort(...)
astype(...)
byteswap(...)
choose(...)
clip(...)
compress(...)
conj(...)
conjugate(...)
copy(...)
cumprod(...)
cumsum(...)
diagonal(...)
dump(...)
dumps(...)
fill(...)
flatten(...)
getfield(...)
item(...)
itemset(...)
max(...)
mean(...)
min(...)
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:
 
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
 
Parameters
----------
new_order : string, 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(...)
prod(...)
ptp(...)
put(...)
ravel(...)
repeat(...)
reshape(...)
resize(...)
round(...)
searchsorted(...)
setfield(...)
setflags(...)
sort(...)
squeeze(...)
std(...)
sum(...)
swapaxes(...)
take(...)
tofile(...)
tolist(...)
tostring(...)
trace(...)
transpose(...)
var(...)
view(...)

Data descriptors inherited from generic:
T
transpose
__array_interface__
Array protocol: Python side
__array_priority__
Array priority.
__array_struct__
Array protocol: struct
base
base object
data
pointer to start of data
dtype
get array data-descriptor
flags
integer value of flags
flat
a 1-d view of scalar
imag
imaginary part of scalar
itemsize
length of one element in bytes
nbytes
length of item in bytes
ndim
number of array dimensions
real
real part of scalar
shape
tuple of array dimensions
size
number of elements in the gentype
strides
tuple of bytes steps in each dimension

 
single = class float32(floating)
    32-bit floating-point number. Character code ``f``.
 
 
Method resolution order:
float32
floating
inexact
number
generic
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 at 0x7f8ebc33b840>
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
__getitem__(...)
x.__getitem__(y) <==> x[y]
__hex__(...)
x.__hex__() <==> hex(x)
__int__(...)
x.__int__() <==> int(x)
__invert__(...)
x.__invert__() <==> ~x
__long__(...)
x.__long__() <==> long(x)
__lshift__(...)
x.__lshift__(y) <==> x<<y
__mod__(...)
x.__mod__(y) <==> x%y
__mul__(...)
x.__mul__(y) <==> x*y
__neg__(...)
x.__neg__() <==> -x
__nonzero__(...)
x.__nonzero__() <==> x != 0
__oct__(...)
x.__oct__() <==> oct(x)
__or__(...)
x.__or__(y) <==> x|y
__pos__(...)
x.__pos__() <==> +x
__pow__(...)
x.__pow__(y[, z]) <==> pow(x, y[, z])
__radd__(...)
x.__radd__(y) <==> y+x
__rand__(...)
x.__rand__(y) <==> y&x
__rdiv__(...)
x.__rdiv__(y) <==> y/x
__rdivmod__(...)
x.__rdivmod__(y) <==> divmod(y, x)
__reduce__(...)
__rfloordiv__(...)
x.__rfloordiv__(y) <==> y//x
__rlshift__(...)
x.__rlshift__(y) <==> y<<x
__rmod__(...)
x.__rmod__(y) <==> y%x
__rmul__(...)
x.__rmul__(y) <==> y*x
__ror__(...)
x.__ror__(y) <==> y|x
__rpow__(...)
y.__rpow__(x[, z]) <==> pow(x, y[, z])
__rrshift__(...)
x.__rrshift__(y) <==> y>>x
__rshift__(...)
x.__rshift__(y) <==> x>>y
__rsub__(...)
x.__rsub__(y) <==> y-x
__rtruediv__(...)
x.__rtruediv__(y) <==> y/x
__rxor__(...)
x.__rxor__(y) <==> y^x
__setstate__(...)
__sub__(...)
x.__sub__(y) <==> x-y
__truediv__(...)
x.__truediv__(y) <==> x/y
__xor__(...)
x.__xor__(y) <==> x^y
all(...)
any(...)
argmax(...)
argmin(...)
argsort(...)
astype(...)
byteswap(...)
choose(...)
clip(...)
compress(...)
conj(...)
conjugate(...)
copy(...)
cumprod(...)
cumsum(...)
diagonal(...)
dump(...)
dumps(...)
fill(...)
flatten(...)
getfield(...)
item(...)
itemset(...)
max(...)
mean(...)
min(...)
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:
 
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
 
Parameters
----------
new_order : string, 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(...)
prod(...)
ptp(...)
put(...)
ravel(...)
repeat(...)
reshape(...)
resize(...)
round(...)
searchsorted(...)
setfield(...)
setflags(...)
sort(...)
squeeze(...)
std(...)
sum(...)
swapaxes(...)
take(...)
tofile(...)
tolist(...)
tostring(...)
trace(...)
transpose(...)
var(...)
view(...)

Data descriptors inherited from generic:
T
transpose
__array_interface__
Array protocol: Python side
__array_priority__
Array priority.
__array_struct__
Array protocol: struct
base
base object
data
pointer to start of data
dtype
get array data-descriptor
flags
integer value of flags
flat
a 1-d view of scalar
imag
imaginary part of scalar
itemsize
length of one element in bytes
nbytes
length of item in bytes
ndim
number of array dimensions
real
real part of scalar
shape
tuple of array dimensions
size
number of elements in the gentype
strides
tuple of bytes steps in each dimension

 
singlecomplex = class complex64(complexfloating)
    Composed of two 32 bit floats
 
 
Method resolution order:
complex64
complexfloating
inexact
number
generic
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 at 0x7f8ebc33bd20>
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
__getitem__(...)
x.__getitem__(y) <==> x[y]
__hex__(...)
x.__hex__() <==> hex(x)
__int__(...)
x.__int__() <==> int(x)
__invert__(...)
x.__invert__() <==> ~x
__long__(...)
x.__long__() <==> long(x)
__lshift__(...)
x.__lshift__(y) <==> x<<y
__mod__(...)
x.__mod__(y) <==> x%y
__mul__(...)
x.__mul__(y) <==> x*y
__neg__(...)
x.__neg__() <==> -x
__nonzero__(...)
x.__nonzero__() <==> x != 0
__oct__(...)
x.__oct__() <==> oct(x)
__or__(...)
x.__or__(y) <==> x|y
__pos__(...)
x.__pos__() <==> +x
__pow__(...)
x.__pow__(y[, z]) <==> pow(x, y[, z])
__radd__(...)
x.__radd__(y) <==> y+x
__rand__(...)
x.__rand__(y) <==> y&x
__rdiv__(...)
x.__rdiv__(y) <==> y/x
__rdivmod__(...)
x.__rdivmod__(y) <==> divmod(y, x)
__reduce__(...)
__rfloordiv__(...)
x.__rfloordiv__(y) <==> y//x
__rlshift__(...)
x.__rlshift__(y) <==> y<<x
__rmod__(...)
x.__rmod__(y) <==> y%x
__rmul__(...)
x.__rmul__(y) <==> y*x
__ror__(...)
x.__ror__(y) <==> y|x
__rpow__(...)
y.__rpow__(x[, z]) <==> pow(x, y[, z])
__rrshift__(...)
x.__rrshift__(y) <==> y>>x
__rshift__(...)
x.__rshift__(y) <==> x>>y
__rsub__(...)
x.__rsub__(y) <==> y-x
__rtruediv__(...)
x.__rtruediv__(y) <==> y/x
__rxor__(...)
x.__rxor__(y) <==> y^x
__setstate__(...)
__sub__(...)
x.__sub__(y) <==> x-y
__truediv__(...)
x.__truediv__(y) <==> x/y
__xor__(...)
x.__xor__(y) <==> x^y
all(...)
any(...)
argmax(...)
argmin(...)
argsort(...)
astype(...)
byteswap(...)
choose(...)
clip(...)
compress(...)
conj(...)
conjugate(...)
copy(...)
cumprod(...)
cumsum(...)
diagonal(...)
dump(...)
dumps(...)
fill(...)
flatten(...)
getfield(...)
item(...)
itemset(...)
max(...)
mean(...)
min(...)
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:
 
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
 
Parameters
----------
new_order : string, 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(...)
prod(...)
ptp(...)
put(...)
ravel(...)
repeat(...)
reshape(...)
resize(...)
round(...)
searchsorted(...)
setfield(...)
setflags(...)
sort(...)
squeeze(...)
std(...)
sum(...)
swapaxes(...)
take(...)
tofile(...)
tolist(...)
tostring(...)
trace(...)
transpose(...)
var(...)
view(...)

Data descriptors inherited from generic:
T
transpose
__array_interface__
Array protocol: Python side
__array_priority__
Array priority.
__array_struct__
Array protocol: struct
base
base object
data
pointer to start of data
dtype
get array data-descriptor
flags
integer value of flags
flat
a 1-d view of scalar
imag
imaginary part of scalar
itemsize
length of one element in bytes
nbytes
length of item in bytes
ndim
number of array dimensions
real
real part of scalar
shape
tuple of array dimensions
size
number of elements in the gentype
strides
tuple of bytes steps in each dimension

 
str_ = class string_(str, character)
    
Method resolution order:
string_
str
basestring
character
flexible
generic
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 at 0x7f8ebc33c3a0>
T.__new__(S, ...) -> a new object with type S, a subtype of T

Methods inherited from str:
__add__(...)
x.__add__(y) <==> x+y
__contains__(...)
x.__contains__(y) <==> y in x
__format__(...)
S.__format__(format_spec) -> unicode
__getattribute__(...)
x.__getattribute__('name') <==> x.name
__getitem__(...)
x.__getitem__(y) <==> x[y]
__getnewargs__(...)
__getslice__(...)
x.__getslice__(i, j) <==> x[i:j]
 
Use of negative indices is not supported.
__len__(...)
x.__len__() <==> len(x)
__mod__(...)
x.__mod__(y) <==> x%y
__mul__(...)
x.__mul__(n) <==> x*n
__rmod__(...)
x.__rmod__(y) <==> y%x
__rmul__(...)
x.__rmul__(n) <==> n*x
__sizeof__(...)
S.__sizeof__() -> size of S in memory, in bytes
capitalize(...)
S.capitalize() -> string
 
Return a copy of the string S with only its first character
capitalized.
center(...)
S.center(width[, fillchar]) -> string
 
Return S centered in a string of length width. Padding is
done using the specified fill character (default is a space)
count(...)
S.count(sub[, start[, end]]) -> int
 
Return the number of non-overlapping occurrences of substring sub in
string S[start:end].  Optional arguments start and end are interpreted
as in slice notation.
decode(...)
S.decode([encoding[,errors]]) -> object
 
Decodes S using the codec registered for encoding. encoding defaults
to the default encoding. errors may be given to set a different error
handling scheme. Default is 'strict' meaning that encoding errors raise
a UnicodeDecodeError. Other possible values are 'ignore' and 'replace'
as well as any other name registered with codecs.register_error that is
able to handle UnicodeDecodeErrors.
encode(...)
S.encode([encoding[,errors]]) -> object
 
Encodes S using the codec registered for encoding. encoding defaults
to the default encoding. errors may be given to set a different error
handling scheme. Default is 'strict' meaning that encoding errors raise
a UnicodeEncodeError. Other possible values are 'ignore', 'replace' and
'xmlcharrefreplace' as well as any other name registered with
codecs.register_error that is able to handle UnicodeEncodeErrors.
endswith(...)
S.endswith(suffix[, start[, end]]) -> bool
 
Return True if S ends with the specified suffix, False otherwise.
With optional start, test S beginning at that position.
With optional end, stop comparing S at that position.
suffix can also be a tuple of strings to try.
expandtabs(...)
S.expandtabs([tabsize]) -> string
 
Return a copy of S where all tab characters are expanded using spaces.
If tabsize is not given, a tab size of 8 characters is assumed.
find(...)
S.find(sub [,start [,end]]) -> int
 
Return the lowest index in S where substring sub is found,
such that sub is contained within s[start:end].  Optional
arguments start and end are interpreted as in slice notation.
 
Return -1 on failure.
format(...)
S.format(*args, **kwargs) -> unicode
index(...)
S.index(sub [,start [,end]]) -> int
 
Like S.find() but raise ValueError when the substring is not found.
isalnum(...)
S.isalnum() -> bool
 
Return True if all characters in S are alphanumeric
and there is at least one character in S, False otherwise.
isalpha(...)
S.isalpha() -> bool
 
Return True if all characters in S are alphabetic
and there is at least one character in S, False otherwise.
isdigit(...)
S.isdigit() -> bool
 
Return True if all characters in S are digits
and there is at least one character in S, False otherwise.
islower(...)
S.islower() -> bool
 
Return True if all cased characters in S are lowercase and there is
at least one cased character in S, False otherwise.
isspace(...)
S.isspace() -> bool
 
Return True if all characters in S are whitespace
and there is at least one character in S, False otherwise.
istitle(...)
S.istitle() -> bool
 
Return True if S is a titlecased string and there is at least one
character in S, i.e. uppercase characters may only follow uncased
characters and lowercase characters only cased ones. Return False
otherwise.
isupper(...)
S.isupper() -> bool
 
Return True if all cased characters in S are uppercase and there is
at least one cased character in S, False otherwise.
join(...)
S.join(sequence) -> string
 
Return a string which is the concatenation of the strings in the
sequence.  The separator between elements is S.
ljust(...)
S.ljust(width[, fillchar]) -> string
 
Return S left-justified in a string of length width. Padding is
done using the specified fill character (default is a space).
lower(...)
S.lower() -> string
 
Return a copy of the string S converted to lowercase.
lstrip(...)
S.lstrip([chars]) -> string or unicode
 
Return a copy of the string S with leading whitespace removed.
If chars is given and not None, remove characters in chars instead.
If chars is unicode, S will be converted to unicode before stripping
partition(...)
S.partition(sep) -> (head, sep, tail)
 
Search for the separator sep in S, and return the part before it,
the separator itself, and the part after it.  If the separator is not
found, return S and two empty strings.
replace(...)
S.replace (old, new[, count]) -> string
 
Return a copy of string S with all occurrences of substring
old replaced by new.  If the optional argument count is
given, only the first count occurrences are replaced.
rfind(...)
S.rfind(sub [,start [,end]]) -> int
 
Return the highest index in S where substring sub is found,
such that sub is contained within s[start:end].  Optional
arguments start and end are interpreted as in slice notation.
 
Return -1 on failure.
rindex(...)
S.rindex(sub [,start [,end]]) -> int
 
Like S.rfind() but raise ValueError when the substring is not found.
rjust(...)
S.rjust(width[, fillchar]) -> string
 
Return S right-justified in a string of length width. Padding is
done using the specified fill character (default is a space)
rpartition(...)
S.rpartition(sep) -> (tail, sep, head)
 
Search for the separator sep in S, starting at the end of S, and return
the part before it, the separator itself, and the part after it.  If the
separator is not found, return two empty strings and S.
rsplit(...)
S.rsplit([sep [,maxsplit]]) -> list of strings
 
Return a list of the words in the string S, using sep as the
delimiter string, starting at the end of the string and working
to the front.  If maxsplit is given, at most maxsplit splits are
done. If sep is not specified or is None, any whitespace string
is a separator.
rstrip(...)
S.rstrip([chars]) -> string or unicode
 
Return a copy of the string S with trailing whitespace removed.
If chars is given and not None, remove characters in chars instead.
If chars is unicode, S will be converted to unicode before stripping
split(...)
S.split([sep [,maxsplit]]) -> list of strings
 
Return a list of the words in the string S, using sep as the
delimiter string.  If maxsplit is given, at most maxsplit
splits are done. If sep is not specified or is None, any
whitespace string is a separator and empty strings are removed
from the result.
splitlines(...)
S.splitlines([keepends]) -> list of strings
 
Return a list of the lines in S, breaking at line boundaries.
Line breaks are not included in the resulting list unless keepends
is given and true.
startswith(...)
S.startswith(prefix[, start[, end]]) -> bool
 
Return True if S starts with the specified prefix, False otherwise.
With optional start, test S beginning at that position.
With optional end, stop comparing S at that position.
prefix can also be a tuple of strings to try.
strip(...)
S.strip([chars]) -> string or unicode
 
Return a copy of the string S with leading and trailing
whitespace removed.
If chars is given and not None, remove characters in chars instead.
If chars is unicode, S will be converted to unicode before stripping
swapcase(...)
S.swapcase() -> string
 
Return a copy of the string S with uppercase characters
converted to lowercase and vice versa.
title(...)
S.title() -> string
 
Return a titlecased version of S, i.e. words start with uppercase
characters, all remaining cased characters have lowercase.
translate(...)
S.translate(table [,deletechars]) -> string
 
Return a copy of the string S, where all characters occurring
in the optional argument deletechars are removed, and the
remaining characters have been mapped through the given
translation table, which must be a string of length 256.
upper(...)
S.upper() -> string
 
Return a copy of the string S converted to uppercase.
zfill(...)
S.zfill(width) -> string
 
Pad a numeric string S with zeros on the left, to fill a field
of the specified width.  The string S is never truncated.

Methods inherited from generic:
__abs__(...)
x.__abs__() <==> abs(x)
__and__(...)
x.__and__(y) <==> x&y
__array__(...)
sc.__array__(|type) return 0-dim array
__array_wrap__(...)
sc.__array_wrap__(obj) return scalar from array
__copy__(...)
__deepcopy__(...)
__div__(...)
x.__div__(y) <==> x/y
__divmod__(...)
x.__divmod__(y) <==> divmod(x, y)
__float__(...)
x.__float__() <==> float(x)
__floordiv__(...)
x.__floordiv__(y) <==> x//y
__hex__(...)
x.__hex__() <==> hex(x)
__int__(...)
x.__int__() <==> int(x)
__invert__(...)
x.__invert__() <==> ~x
__long__(...)
x.__long__() <==> long(x)
__lshift__(...)
x.__lshift__(y) <==> x<<y
__neg__(...)
x.__neg__() <==> -x
__nonzero__(...)
x.__nonzero__() <==> x != 0
__oct__(...)
x.__oct__() <==> oct(x)
__or__(...)
x.__or__(y) <==> x|y
__pos__(...)
x.__pos__() <==> +x
__pow__(...)
x.__pow__(y[, z]) <==> pow(x, y[, z])
__radd__(...)
x.__radd__(y) <==> y+x
__rand__(...)
x.__rand__(y) <==> y&x
__rdiv__(...)
x.__rdiv__(y) <==> y/x
__rdivmod__(...)
x.__rdivmod__(y) <==> divmod(y, x)
__reduce__(...)
__rfloordiv__(...)
x.__rfloordiv__(y) <==> y//x
__rlshift__(...)
x.__rlshift__(y) <==> y<<x
__ror__(...)
x.__ror__(y) <==> y|x
__rpow__(...)
y.__rpow__(x[, z]) <==> pow(x, y[, z])
__rrshift__(...)
x.__rrshift__(y) <==> y>>x
__rshift__(...)
x.__rshift__(y) <==> x>>y
__rsub__(...)
x.__rsub__(y) <==> y-x
__rtruediv__(...)
x.__rtruediv__(y) <==> y/x
__rxor__(...)
x.__rxor__(y) <==> y^x
__setstate__(...)
__sub__(...)
x.__sub__(y) <==> x-y
__truediv__(...)
x.__truediv__(y) <==> x/y
__xor__(...)
x.__xor__(y) <==> x^y
all(...)
any(...)
argmax(...)
argmin(...)
argsort(...)
astype(...)
byteswap(...)
choose(...)
clip(...)
compress(...)
conj(...)
conjugate(...)
copy(...)
cumprod(...)
cumsum(...)
diagonal(...)
dump(...)
dumps(...)
fill(...)
flatten(...)
getfield(...)
item(...)
itemset(...)
max(...)
mean(...)
min(...)
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:
 
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
 
Parameters
----------
new_order : string, 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(...)
prod(...)
ptp(...)
put(...)
ravel(...)
repeat(...)
reshape(...)
resize(...)
round(...)
searchsorted(...)
setfield(...)
setflags(...)
sort(...)
squeeze(...)
std(...)
sum(...)
swapaxes(...)
take(...)
tofile(...)
tolist(...)
tostring(...)
trace(...)
transpose(...)
var(...)
view(...)

Data descriptors inherited from generic:
T
transpose
__array_interface__
Array protocol: Python side
__array_priority__
Array priority.
__array_struct__
Array protocol: struct
base
base object
data
pointer to start of data
dtype
get array data-descriptor
flags
integer value of flags
flat
a 1-d view of scalar
imag
imaginary part of scalar
itemsize
length of one element in bytes
nbytes
length of item in bytes
ndim
number of array dimensions
real
real part of scalar
shape
tuple of array dimensions
size
number of elements in the gentype
strides
tuple of bytes steps in each dimension

 
string0 = class string_(str, character)
    
Method resolution order:
string_
str
basestring
character
flexible
generic
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 at 0x7f8ebc33c3a0>
T.__new__(S, ...) -> a new object with type S, a subtype of T

Methods inherited from str:
__add__(...)
x.__add__(y) <==> x+y
__contains__(...)
x.__contains__(y) <==> y in x
__format__(...)
S.__format__(format_spec) -> unicode
__getattribute__(...)
x.__getattribute__('name') <==> x.name
__getitem__(...)
x.__getitem__(y) <==> x[y]
__getnewargs__(...)
__getslice__(...)
x.__getslice__(i, j) <==> x[i:j]
 
Use of negative indices is not supported.
__len__(...)
x.__len__() <==> len(x)
__mod__(...)
x.__mod__(y) <==> x%y
__mul__(...)
x.__mul__(n) <==> x*n
__rmod__(...)
x.__rmod__(y) <==> y%x
__rmul__(...)
x.__rmul__(n) <==> n*x
__sizeof__(...)
S.__sizeof__() -> size of S in memory, in bytes
capitalize(...)
S.capitalize() -> string
 
Return a copy of the string S with only its first character
capitalized.
center(...)
S.center(width[, fillchar]) -> string
 
Return S centered in a string of length width. Padding is
done using the specified fill character (default is a space)
count(...)
S.count(sub[, start[, end]]) -> int
 
Return the number of non-overlapping occurrences of substring sub in
string S[start:end].  Optional arguments start and end are interpreted
as in slice notation.
decode(...)
S.decode([encoding[,errors]]) -> object
 
Decodes S using the codec registered for encoding. encoding defaults
to the default encoding. errors may be given to set a different error
handling scheme. Default is 'strict' meaning that encoding errors raise
a UnicodeDecodeError. Other possible values are 'ignore' and 'replace'
as well as any other name registered with codecs.register_error that is
able to handle UnicodeDecodeErrors.
encode(...)
S.encode([encoding[,errors]]) -> object
 
Encodes S using the codec registered for encoding. encoding defaults
to the default encoding. errors may be given to set a different error
handling scheme. Default is 'strict' meaning that encoding errors raise
a UnicodeEncodeError. Other possible values are 'ignore', 'replace' and
'xmlcharrefreplace' as well as any other name registered with
codecs.register_error that is able to handle UnicodeEncodeErrors.
endswith(...)
S.endswith(suffix[, start[, end]]) -> bool
 
Return True if S ends with the specified suffix, False otherwise.
With optional start, test S beginning at that position.
With optional end, stop comparing S at that position.
suffix can also be a tuple of strings to try.
expandtabs(...)
S.expandtabs([tabsize]) -> string
 
Return a copy of S where all tab characters are expanded using spaces.
If tabsize is not given, a tab size of 8 characters is assumed.
find(...)
S.find(sub [,start [,end]]) -> int
 
Return the lowest index in S where substring sub is found,
such that sub is contained within s[start:end].  Optional
arguments start and end are interpreted as in slice notation.
 
Return -1 on failure.
format(...)
S.format(*args, **kwargs) -> unicode
index(...)
S.index(sub [,start [,end]]) -> int
 
Like S.find() but raise ValueError when the substring is not found.
isalnum(...)
S.isalnum() -> bool
 
Return True if all characters in S are alphanumeric
and there is at least one character in S, False otherwise.
isalpha(...)
S.isalpha() -> bool
 
Return True if all characters in S are alphabetic
and there is at least one character in S, False otherwise.
isdigit(...)
S.isdigit() -> bool
 
Return True if all characters in S are digits
and there is at least one character in S, False otherwise.
islower(...)
S.islower() -> bool
 
Return True if all cased characters in S are lowercase and there is
at least one cased character in S, False otherwise.
isspace(...)
S.isspace() -> bool
 
Return True if all characters in S are whitespace
and there is at least one character in S, False otherwise.
istitle(...)
S.istitle() -> bool
 
Return True if S is a titlecased string and there is at least one
character in S, i.e. uppercase characters may only follow uncased
characters and lowercase characters only cased ones. Return False
otherwise.
isupper(...)
S.isupper() -> bool
 
Return True if all cased characters in S are uppercase and there is
at least one cased character in S, False otherwise.
join(...)
S.join(sequence) -> string
 
Return a string which is the concatenation of the strings in the
sequence.  The separator between elements is S.
ljust(...)
S.ljust(width[, fillchar]) -> string
 
Return S left-justified in a string of length width. Padding is
done using the specified fill character (default is a space).
lower(...)
S.lower() -> string
 
Return a copy of the string S converted to lowercase.
lstrip(...)
S.lstrip([chars]) -> string or unicode
 
Return a copy of the string S with leading whitespace removed.
If chars is given and not None, remove characters in chars instead.
If chars is unicode, S will be converted to unicode before stripping
partition(...)
S.partition(sep) -> (head, sep, tail)
 
Search for the separator sep in S, and return the part before it,
the separator itself, and the part after it.  If the separator is not
found, return S and two empty strings.
replace(...)
S.replace (old, new[, count]) -> string
 
Return a copy of string S with all occurrences of substring
old replaced by new.  If the optional argument count is
given, only the first count occurrences are replaced.
rfind(...)
S.rfind(sub [,start [,end]]) -> int
 
Return the highest index in S where substring sub is found,
such that sub is contained within s[start:end].  Optional
arguments start and end are interpreted as in slice notation.
 
Return -1 on failure.
rindex(...)
S.rindex(sub [,start [,end]]) -> int
 
Like S.rfind() but raise ValueError when the substring is not found.
rjust(...)
S.rjust(width[, fillchar]) -> string
 
Return S right-justified in a string of length width. Padding is
done using the specified fill character (default is a space)
rpartition(...)
S.rpartition(sep) -> (tail, sep, head)
 
Search for the separator sep in S, starting at the end of S, and return
the part before it, the separator itself, and the part after it.  If the
separator is not found, return two empty strings and S.
rsplit(...)
S.rsplit([sep [,maxsplit]]) -> list of strings
 
Return a list of the words in the string S, using sep as the
delimiter string, starting at the end of the string and working
to the front.  If maxsplit is given, at most maxsplit splits are
done. If sep is not specified or is None, any whitespace string
is a separator.
rstrip(...)
S.rstrip([chars]) -> string or unicode
 
Return a copy of the string S with trailing whitespace removed.
If chars is given and not None, remove characters in chars instead.
If chars is unicode, S will be converted to unicode before stripping
split(...)
S.split([sep [,maxsplit]]) -> list of strings
 
Return a list of the words in the string S, using sep as the
delimiter string.  If maxsplit is given, at most maxsplit
splits are done. If sep is not specified or is None, any
whitespace string is a separator and empty strings are removed
from the result.
splitlines(...)
S.splitlines([keepends]) -> list of strings
 
Return a list of the lines in S, breaking at line boundaries.
Line breaks are not included in the resulting list unless keepends
is given and true.
startswith(...)
S.startswith(prefix[, start[, end]]) -> bool
 
Return True if S starts with the specified prefix, False otherwise.
With optional start, test S beginning at that position.
With optional end, stop comparing S at that position.
prefix can also be a tuple of strings to try.
strip(...)
S.strip([chars]) -> string or unicode
 
Return a copy of the string S with leading and trailing
whitespace removed.
If chars is given and not None, remove characters in chars instead.
If chars is unicode, S will be converted to unicode before stripping
swapcase(...)
S.swapcase() -> string
 
Return a copy of the string S with uppercase characters
converted to lowercase and vice versa.
title(...)
S.title() -> string
 
Return a titlecased version of S, i.e. words start with uppercase
characters, all remaining cased characters have lowercase.
translate(...)
S.translate(table [,deletechars]) -> string
 
Return a copy of the string S, where all characters occurring
in the optional argument deletechars are removed, and the
remaining characters have been mapped through the given
translation table, which must be a string of length 256.
upper(...)
S.upper() -> string
 
Return a copy of the string S converted to uppercase.
zfill(...)
S.zfill(width) -> string
 
Pad a numeric string S with zeros on the left, to fill a field
of the specified width.  The string S is never truncated.

Methods inherited from generic:
__abs__(...)
x.__abs__() <==> abs(x)
__and__(...)
x.__and__(y) <==> x&y
__array__(...)
sc.__array__(|type) return 0-dim array
__array_wrap__(...)
sc.__array_wrap__(obj) return scalar from array
__copy__(...)
__deepcopy__(...)
__div__(...)
x.__div__(y) <==> x/y
__divmod__(...)
x.__divmod__(y) <==> divmod(x, y)
__float__(...)
x.__float__() <==> float(x)
__floordiv__(...)
x.__floordiv__(y) <==> x//y
__hex__(...)
x.__hex__() <==> hex(x)
__int__(...)
x.__int__() <==> int(x)
__invert__(...)
x.__invert__() <==> ~x
__long__(...)
x.__long__() <==> long(x)
__lshift__(...)
x.__lshift__(y) <==> x<<y
__neg__(...)
x.__neg__() <==> -x
__nonzero__(...)
x.__nonzero__() <==> x != 0
__oct__(...)
x.__oct__() <==> oct(x)
__or__(...)
x.__or__(y) <==> x|y
__pos__(...)
x.__pos__() <==> +x
__pow__(...)
x.__pow__(y[, z]) <==> pow(x, y[, z])
__radd__(...)
x.__radd__(y) <==> y+x
__rand__(...)
x.__rand__(y) <==> y&x
__rdiv__(...)
x.__rdiv__(y) <==> y/x
__rdivmod__(...)
x.__rdivmod__(y) <==> divmod(y, x)
__reduce__(...)
__rfloordiv__(...)
x.__rfloordiv__(y) <==> y//x
__rlshift__(...)
x.__rlshift__(y) <==> y<<x
__ror__(...)
x.__ror__(y) <==> y|x
__rpow__(...)
y.__rpow__(x[, z]) <==> pow(x, y[, z])
__rrshift__(...)
x.__rrshift__(y) <==> y>>x
__rshift__(...)
x.__rshift__(y) <==> x>>y
__rsub__(...)
x.__rsub__(y) <==> y-x
__rtruediv__(...)
x.__rtruediv__(y) <==> y/x
__rxor__(...)
x.__rxor__(y) <==> y^x
__setstate__(...)
__sub__(...)
x.__sub__(y) <==> x-y
__truediv__(...)
x.__truediv__(y) <==> x/y
__xor__(...)
x.__xor__(y) <==> x^y
all(...)
any(...)
argmax(...)
argmin(...)
argsort(...)
astype(...)
byteswap(...)
choose(...)
clip(...)
compress(...)
conj(...)
conjugate(...)
copy(...)
cumprod(...)
cumsum(...)
diagonal(...)
dump(...)
dumps(...)
fill(...)
flatten(...)
getfield(...)
item(...)
itemset(...)
max(...)
mean(...)
min(...)
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:
 
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
 
Parameters
----------
new_order : string, 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(...)
prod(...)
ptp(...)
put(...)
ravel(...)
repeat(...)
reshape(...)
resize(...)
round(...)
searchsorted(...)
setfield(...)
setflags(...)
sort(...)
squeeze(...)
std(...)
sum(...)
swapaxes(...)
take(...)
tofile(...)
tolist(...)
tostring(...)
trace(...)
transpose(...)
var(...)
view(...)

Data descriptors inherited from generic:
T
transpose
__array_interface__
Array protocol: Python side
__array_priority__
Array priority.
__array_struct__
Array protocol: struct
base
base object
data
pointer to start of data
dtype
get array data-descriptor
flags
integer value of flags
flat
a 1-d view of scalar
imag
imaginary part of scalar
itemsize
length of one element in bytes
nbytes
length of item in bytes
ndim
number of array dimensions
real
real part of scalar
shape
tuple of array dimensions
size
number of elements in the gentype
strides
tuple of bytes steps in each dimension

 
class string_(str, character)
    
Method resolution order:
string_
str
basestring
character
flexible
generic
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 at 0x7f8ebc33c3a0>
T.__new__(S, ...) -> a new object with type S, a subtype of T

Methods inherited from str:
__add__(...)
x.__add__(y) <==> x+y
__contains__(...)
x.__contains__(y) <==> y in x
__format__(...)
S.__format__(format_spec) -> unicode
__getattribute__(...)
x.__getattribute__('name') <==> x.name
__getitem__(...)
x.__getitem__(y) <==> x[y]
__getnewargs__(...)
__getslice__(...)
x.__getslice__(i, j) <==> x[i:j]
 
Use of negative indices is not supported.
__len__(...)
x.__len__() <==> len(x)
__mod__(...)
x.__mod__(y) <==> x%y
__mul__(...)
x.__mul__(n) <==> x*n
__rmod__(...)
x.__rmod__(y) <==> y%x
__rmul__(...)
x.__rmul__(n) <==> n*x
__sizeof__(...)
S.__sizeof__() -> size of S in memory, in bytes
capitalize(...)
S.capitalize() -> string
 
Return a copy of the string S with only its first character
capitalized.
center(...)
S.center(width[, fillchar]) -> string
 
Return S centered in a string of length width. Padding is
done using the specified fill character (default is a space)
count(...)
S.count(sub[, start[, end]]) -> int
 
Return the number of non-overlapping occurrences of substring sub in
string S[start:end].  Optional arguments start and end are interpreted
as in slice notation.
decode(...)
S.decode([encoding[,errors]]) -> object
 
Decodes S using the codec registered for encoding. encoding defaults
to the default encoding. errors may be given to set a different error
handling scheme. Default is 'strict' meaning that encoding errors raise
a UnicodeDecodeError. Other possible values are 'ignore' and 'replace'
as well as any other name registered with codecs.register_error that is
able to handle UnicodeDecodeErrors.
encode(...)
S.encode([encoding[,errors]]) -> object
 
Encodes S using the codec registered for encoding. encoding defaults
to the default encoding. errors may be given to set a different error
handling scheme. Default is 'strict' meaning that encoding errors raise
a UnicodeEncodeError. Other possible values are 'ignore', 'replace' and
'xmlcharrefreplace' as well as any other name registered with
codecs.register_error that is able to handle UnicodeEncodeErrors.
endswith(...)
S.endswith(suffix[, start[, end]]) -> bool
 
Return True if S ends with the specified suffix, False otherwise.
With optional start, test S beginning at that position.
With optional end, stop comparing S at that position.
suffix can also be a tuple of strings to try.
expandtabs(...)
S.expandtabs([tabsize]) -> string
 
Return a copy of S where all tab characters are expanded using spaces.
If tabsize is not given, a tab size of 8 characters is assumed.
find(...)
S.find(sub [,start [,end]]) -> int
 
Return the lowest index in S where substring sub is found,
such that sub is contained within s[start:end].  Optional
arguments start and end are interpreted as in slice notation.
 
Return -1 on failure.
format(...)
S.format(*args, **kwargs) -> unicode
index(...)
S.index(sub [,start [,end]]) -> int
 
Like S.find() but raise ValueError when the substring is not found.
isalnum(...)
S.isalnum() -> bool
 
Return True if all characters in S are alphanumeric
and there is at least one character in S, False otherwise.
isalpha(...)
S.isalpha() -> bool
 
Return True if all characters in S are alphabetic
and there is at least one character in S, False otherwise.
isdigit(...)
S.isdigit() -> bool
 
Return True if all characters in S are digits
and there is at least one character in S, False otherwise.
islower(...)
S.islower() -> bool
 
Return True if all cased characters in S are lowercase and there is
at least one cased character in S, False otherwise.
isspace(...)
S.isspace() -> bool
 
Return True if all characters in S are whitespace
and there is at least one character in S, False otherwise.
istitle(...)
S.istitle() -> bool
 
Return True if S is a titlecased string and there is at least one
character in S, i.e. uppercase characters may only follow uncased
characters and lowercase characters only cased ones. Return False
otherwise.
isupper(...)
S.isupper() -> bool
 
Return True if all cased characters in S are uppercase and there is
at least one cased character in S, False otherwise.
join(...)
S.join(sequence) -> string
 
Return a string which is the concatenation of the strings in the
sequence.  The separator between elements is S.
ljust(...)
S.ljust(width[, fillchar]) -> string
 
Return S left-justified in a string of length width. Padding is
done using the specified fill character (default is a space).
lower(...)
S.lower() -> string
 
Return a copy of the string S converted to lowercase.
lstrip(...)
S.lstrip([chars]) -> string or unicode
 
Return a copy of the string S with leading whitespace removed.
If chars is given and not None, remove characters in chars instead.
If chars is unicode, S will be converted to unicode before stripping
partition(...)
S.partition(sep) -> (head, sep, tail)
 
Search for the separator sep in S, and return the part before it,
the separator itself, and the part after it.  If the separator is not
found, return S and two empty strings.
replace(...)
S.replace (old, new[, count]) -> string
 
Return a copy of string S with all occurrences of substring
old replaced by new.  If the optional argument count is
given, only the first count occurrences are replaced.
rfind(...)
S.rfind(sub [,start [,end]]) -> int
 
Return the highest index in S where substring sub is found,
such that sub is contained within s[start:end].  Optional
arguments start and end are interpreted as in slice notation.
 
Return -1 on failure.
rindex(...)
S.rindex(sub [,start [,end]]) -> int
 
Like S.rfind() but raise ValueError when the substring is not found.
rjust(...)
S.rjust(width[, fillchar]) -> string
 
Return S right-justified in a string of length width. Padding is
done using the specified fill character (default is a space)
rpartition(...)
S.rpartition(sep) -> (tail, sep, head)
 
Search for the separator sep in S, starting at the end of S, and return
the part before it, the separator itself, and the part after it.  If the
separator is not found, return two empty strings and S.
rsplit(...)
S.rsplit([sep [,maxsplit]]) -> list of strings
 
Return a list of the words in the string S, using sep as the
delimiter string, starting at the end of the string and working
to the front.  If maxsplit is given, at most maxsplit splits are
done. If sep is not specified or is None, any whitespace string
is a separator.
rstrip(...)
S.rstrip([chars]) -> string or unicode
 
Return a copy of the string S with trailing whitespace removed.
If chars is given and not None, remove characters in chars instead.
If chars is unicode, S will be converted to unicode before stripping
split(...)
S.split([sep [,maxsplit]]) -> list of strings
 
Return a list of the words in the string S, using sep as the
delimiter string.  If maxsplit is given, at most maxsplit
splits are done. If sep is not specified or is None, any
whitespace string is a separator and empty strings are removed
from the result.
splitlines(...)
S.splitlines([keepends]) -> list of strings
 
Return a list of the lines in S, breaking at line boundaries.
Line breaks are not included in the resulting list unless keepends
is given and true.
startswith(...)
S.startswith(prefix[, start[, end]]) -> bool
 
Return True if S starts with the specified prefix, False otherwise.
With optional start, test S beginning at that position.
With optional end, stop comparing S at that position.
prefix can also be a tuple of strings to try.
strip(...)
S.strip([chars]) -> string or unicode
 
Return a copy of the string S with leading and trailing
whitespace removed.
If chars is given and not None, remove characters in chars instead.
If chars is unicode, S will be converted to unicode before stripping
swapcase(...)
S.swapcase() -> string
 
Return a copy of the string S with uppercase characters
converted to lowercase and vice versa.
title(...)
S.title() -> string
 
Return a titlecased version of S, i.e. words start with uppercase
characters, all remaining cased characters have lowercase.
translate(...)
S.translate(table [,deletechars]) -> string
 
Return a copy of the string S, where all characters occurring
in the optional argument deletechars are removed, and the
remaining characters have been mapped through the given
translation table, which must be a string of length 256.
upper(...)
S.upper() -> string
 
Return a copy of the string S converted to uppercase.
zfill(...)
S.zfill(width) -> string
 
Pad a numeric string S with zeros on the left, to fill a field
of the specified width.  The string S is never truncated.

Methods inherited from generic:
__abs__(...)
x.__abs__() <==> abs(x)
__and__(...)
x.__and__(y) <==> x&y
__array__(...)
sc.__array__(|type) return 0-dim array
__array_wrap__(...)
sc.__array_wrap__(obj) return scalar from array
__copy__(...)
__deepcopy__(...)
__div__(...)
x.__div__(y) <==> x/y
__divmod__(...)
x.__divmod__(y) <==> divmod(x, y)
__float__(...)
x.__float__() <==> float(x)
__floordiv__(...)
x.__floordiv__(y) <==> x//y
__hex__(...)
x.__hex__() <==> hex(x)
__int__(...)
x.__int__() <==> int(x)
__invert__(...)
x.__invert__() <==> ~x
__long__(...)
x.__long__() <==> long(x)
__lshift__(...)
x.__lshift__(y) <==> x<<y
__neg__(...)
x.__neg__() <==> -x
__nonzero__(...)
x.__nonzero__() <==> x != 0
__oct__(...)
x.__oct__() <==> oct(x)
__or__(...)
x.__or__(y) <==> x|y
__pos__(...)
x.__pos__() <==> +x
__pow__(...)
x.__pow__(y[, z]) <==> pow(x, y[, z])
__radd__(...)
x.__radd__(y) <==> y+x
__rand__(...)
x.__rand__(y) <==> y&x
__rdiv__(...)
x.__rdiv__(y) <==> y/x
__rdivmod__(...)
x.__rdivmod__(y) <==> divmod(y, x)
__reduce__(...)
__rfloordiv__(...)
x.__rfloordiv__(y) <==> y//x
__rlshift__(...)
x.__rlshift__(y) <==> y<<x
__ror__(...)
x.__ror__(y) <==> y|x
__rpow__(...)
y.__rpow__(x[, z]) <==> pow(x, y[, z])
__rrshift__(...)
x.__rrshift__(y) <==> y>>x
__rshift__(...)
x.__rshift__(y) <==> x>>y
__rsub__(...)
x.__rsub__(y) <==> y-x
__rtruediv__(...)
x.__rtruediv__(y) <==> y/x
__rxor__(...)
x.__rxor__(y) <==> y^x
__setstate__(...)
__sub__(...)
x.__sub__(y) <==> x-y
__truediv__(...)
x.__truediv__(y) <==> x/y
__xor__(...)
x.__xor__(y) <==> x^y
all(...)
any(...)
argmax(...)
argmin(...)
argsort(...)
astype(...)
byteswap(...)
choose(...)
clip(...)
compress(...)
conj(...)
conjugate(...)
copy(...)
cumprod(...)
cumsum(...)
diagonal(...)
dump(...)
dumps(...)
fill(...)
flatten(...)
getfield(...)
item(...)
itemset(...)
max(...)
mean(...)
min(...)
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:
 
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
 
Parameters
----------
new_order : string, 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(...)
prod(...)
ptp(...)
put(...)
ravel(...)
repeat(...)
reshape(...)
resize(...)
round(...)
searchsorted(...)
setfield(...)
setflags(...)
sort(...)
squeeze(...)
std(...)
sum(...)
swapaxes(...)
take(...)
tofile(...)
tolist(...)
tostring(...)
trace(...)
transpose(...)
var(...)
view(...)

Data descriptors inherited from generic:
T
transpose
__array_interface__
Array protocol: Python side
__array_priority__
Array priority.
__array_struct__
Array protocol: struct
base
base object
data
pointer to start of data
dtype
get array data-descriptor
flags
integer value of flags
flat
a 1-d view of scalar
imag
imaginary part of scalar
itemsize
length of one element in bytes
nbytes
length of item in bytes
ndim
number of array dimensions
real
real part of scalar
shape
tuple of array dimensions
size
number of elements in the gentype
strides
tuple of bytes steps in each dimension

 
ubyte = class uint8(unsignedinteger)
    
Method resolution order:
uint8
unsignedinteger
integer
number
generic
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 at 0x7f8ebc33b020>
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
__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__(...)
__str__(...)
x.__str__() <==> str(x)
__sub__(...)
x.__sub__(y) <==> x-y
__truediv__(...)
x.__truediv__(y) <==> x/y
__xor__(...)
x.__xor__(y) <==> x^y
all(...)
any(...)
argmax(...)
argmin(...)
argsort(...)
astype(...)
byteswap(...)
choose(...)
clip(...)
compress(...)
conj(...)
conjugate(...)
copy(...)
cumprod(...)
cumsum(...)
diagonal(...)
dump(...)
dumps(...)
fill(...)
flatten(...)
getfield(...)
item(...)
itemset(...)
max(...)
mean(...)
min(...)
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:
 
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
 
Parameters
----------
new_order : string, 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(...)
prod(...)
ptp(...)
put(...)
ravel(...)
repeat(...)
reshape(...)
resize(...)
round(...)
searchsorted(...)
setfield(...)
setflags(...)
sort(...)
squeeze(...)
std(...)
sum(...)
swapaxes(...)
take(...)
tofile(...)
tolist(...)
tostring(...)
trace(...)
transpose(...)
var(...)
view(...)

Data descriptors inherited from generic:
T
transpose
__array_interface__
Array protocol: Python side
__array_priority__
Array priority.
__array_struct__
Array protocol: struct
base
base object
data
pointer to start of data
dtype
get array data-descriptor
flags
integer value of flags
flat
a 1-d view of scalar
imag
imaginary part of scalar
itemsize
length of one element in bytes
nbytes
length of item in bytes
ndim
number of array dimensions
real
real part of scalar
shape
tuple of array dimensions
size
number of elements in the gentype
strides
tuple of bytes steps in each dimension

 
class ufunc(object)
    Functions that operate element by element on whole arrays.
 
Unary ufuncs:
=============
 
op(X, out=None)
Apply op to X elementwise
 
Parameters
----------
X : array_like
    Input array
out : array_like
    An array to store the output. Must be the same shape as X.
 
Returns
-------
r : array_like
    r will have the same shape as X; if out is provided, r will be
    equal to out.
 
Binary ufuncs:
==============
 
op(X, Y, out=None)
Apply op to X and Y elementwise. May "broadcast" to make
the shapes of X and Y congruent.
 
The broadcasting rules are:
* Dimensions of length 1 may be prepended to either array
* Arrays may be repeated along dimensions of length 1
 
Parameters
----------
X : array_like
    First input array
Y : array_like
    Second input array
out : array-like
    An array to store the output. Must be the same shape as the
    output would have.
 
Returns
-------
r : array-like
    The return value; if out is provided, r will be equal to out.
 
  Methods defined here:
__call__(...)
x.__call__(...) <==> x(...)
__repr__(...)
x.__repr__() <==> repr(x)
__str__(...)
x.__str__() <==> str(x)
accumulate(...)
accumulate(array, axis=None, dtype=None, out=None)
 
Accumulate the result of applying the operator to all elements.
 
For a one-dimensional array, accumulate produces results equivalent to:
::
 
 r = np.empty(len(A))
 t = op.identity
 for i in xrange(len(A)):
    t = op(t,A[i])
    r[i] = t
 return r
 
For example, add.accumulate() is equivalent to cumsum().
 
Parameters
----------
array : array_like
    The array to act on.
axis : int, optional
    The axis along which to apply the accumulation.
dtype : data-type-code, optional
    The type used to represent the intermediate results. Defaults
    to the data type of the output array if this is provided, or
    the data type of the input array if no output array is provided.
out : ndarray, optional
    A location into which the result is stored. If not provided a
    freshly-allocated array is returned.
 
Returns
-------
r : ndarray
    The accumulated values. If `out` was supplied, `r` is equal to
    `out`.
 
Examples
--------
>>> np.multiply.accumulate([2,3,5])
array([2,6,30])
outer(...)
outer(A,B)
 
Compute the result of applying op to all pairs (a,b)
 
op.outer(A,B) is equivalent to
op(A[:,:,...,:,newaxis,...,newaxis]*B[newaxis,...,newaxis,:,...,:])
where A has B.ndim new axes appended and B has A.ndim new axes prepended.
 
For A and B one-dimensional, this is equivalent to
::
 
 r = empty(len(A),len(B))
 for i in xrange(len(A)):
     for j in xrange(len(B)):
         r[i,j] = A[i]*B[j]
 
If A and B are higher-dimensional, the result has dimension A.ndim+B.ndim
 
Parameters
----------
A : array_like
    First term
B : array_like
    Second term
 
Returns
-------
r : ndarray
    Output array
 
Examples
--------
>>> np.multiply.outer([1,2,3],[4,5,6])
array([[ 4,  5,  6],
       [ 8, 10, 12],
       [12, 15, 18]])
reduce(...)
reduce(array, axis=0, dtype=None, out=None)
 
Reduce applies the operator to all elements of the array.
 
For a one-dimensional array, reduce produces results equivalent to:
::
 
 r = op.identity
 for i in xrange(len(A)):
   r = op(r,A[i])
 return r
 
For example, add.reduce() is equivalent to sum().
 
Parameters
----------
array : array_like
    The array to act on.
axis : integer, optional
    The axis along which to apply the reduction.
dtype : data-type-code, optional
    The type used to represent the intermediate results. Defaults
    to the data type of the output array if this is provided, or
    the data type of the input array if no output array is provided.
out : array_like, optional
    A location into which the result is stored. If not provided a
    freshly-allocated array is returned.
 
Returns
-------
r : ndarray
    The reduced values. If out was supplied, r is equal to out.
 
Examples
--------
>>> np.multiply.reduce([2,3,5])
30
reduceat(...)
reduceat(self, array, indices, axis=None, dtype=None, out=None)
 
Reduceat performs a reduce with specified slices over an axis.
 
Computes op.reduce(`array[indices[i]:indices[i+1]]`)
for i=0..end with an implicit `indices[i+1]` = len(`array`)
assumed when i = end - 1.
 
If `indices[i]` >= `indices[i + 1]`
then the result is `array[indices[i]]` for that value.
 
The function op.accumulate(`array`) is the same as
op.reduceat(`array`, `indices`)[::2]
where `indices` is range(len(`array`)-1) with a zero placed
in every other sample:
`indices` = zeros(len(`array`)*2 - 1)
`indices[1::2]` = range(1, len(`array`))
 
The output shape is based on the size of `indices`.
 
Parameters
----------
array : array_like
    The array to act on.
indices : array_like
    Paired indices specifying slices to reduce.
axis : int, optional
    The axis along which to apply the reduceat.
dtype : data-type-code, optional
    The type used to represent the intermediate results. Defaults
    to the data type of the output array if this is provided, or
    the data type of the input array if no output array is provided.
out : ndarray, optional
    A location into which the result is stored. If not provided a
    freshly-allocated array is returned.
 
Returns
-------
r : array
    The reduced values. If `out` was supplied, `r` is equal to `out`.
 
Examples
--------
To take the running sum of four successive values:
 
>>> np.add.reduceat(np.arange(8),[0,4, 1,5, 2,6, 3,7])[::2]
array([ 6, 10, 14, 18])

Data descriptors defined here:
identity
identity value
nargs
number of arguments
nin
number of inputs
nout
number of outputs
ntypes
number of types
signature
signature
types
return a list with types grouped input->output

 
uint = class uint64(unsignedinteger)
    
Method resolution order:
uint64
unsignedinteger
integer
number
generic
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 at 0x7f8ebc33b500>
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
__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__(...)
__str__(...)
x.__str__() <==> str(x)
__sub__(...)
x.__sub__(y) <==> x-y
__truediv__(...)
x.__truediv__(y) <==> x/y
__xor__(...)
x.__xor__(y) <==> x^y
all(...)
any(...)
argmax(...)
argmin(...)
argsort(...)
astype(...)
byteswap(...)
choose(...)
clip(...)
compress(...)
conj(...)
conjugate(...)
copy(...)
cumprod(...)
cumsum(...)
diagonal(...)
dump(...)
dumps(...)
fill(...)
flatten(...)
getfield(...)
item(...)
itemset(...)
max(...)
mean(...)
min(...)
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:
 
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
 
Parameters
----------
new_order : string, 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(...)
prod(...)
ptp(...)
put(...)
ravel(...)
repeat(...)
reshape(...)
resize(...)
round(...)
searchsorted(...)
setfield(...)
setflags(...)
sort(...)
squeeze(...)
std(...)
sum(...)
swapaxes(...)
take(...)
tofile(...)
tolist(...)
tostring(...)
trace(...)
transpose(...)
var(...)
view(...)

Data descriptors inherited from generic:
T
transpose
__array_interface__
Array protocol: Python side
__array_priority__
Array priority.
__array_struct__
Array protocol: struct
base
base object
data
pointer to start of data
dtype
get array data-descriptor
flags
integer value of flags
flat
a 1-d view of scalar
imag
imaginary part of scalar
itemsize
length of one element in bytes
nbytes
length of item in bytes
ndim
number of array dimensions
real
real part of scalar
shape
tuple of array dimensions
size
number of elements in the gentype
strides
tuple of bytes steps in each dimension

 
uint0 = class uint64(unsignedinteger)
    
Method resolution order:
uint64
unsignedinteger
integer
number
generic
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 at 0x7f8ebc33b500>
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
__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__(...)
__str__(...)
x.__str__() <==> str(x)
__sub__(...)
x.__sub__(y) <==> x-y
__truediv__(...)
x.__truediv__(y) <==> x/y
__xor__(...)
x.__xor__(y) <==> x^y
all(...)
any(...)
argmax(...)
argmin(...)
argsort(...)
astype(...)
byteswap(...)
choose(...)
clip(...)
compress(...)
conj(...)
conjugate(...)
copy(...)
cumprod(...)
cumsum(...)
diagonal(...)
dump(...)
dumps(...)
fill(...)
flatten(...)
getfield(...)
item(...)
itemset(...)
max(...)
mean(...)
min(...)
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:
 
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
 
Parameters
----------
new_order : string, 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(...)
prod(...)
ptp(...)
put(...)
ravel(...)
repeat(...)
reshape(...)
resize(...)
round(...)
searchsorted(...)
setfield(...)
setflags(...)
sort(...)
squeeze(...)
std(...)
sum(...)
swapaxes(...)
take(...)
tofile(...)
tolist(...)
tostring(...)
trace(...)
transpose(...)
var(...)
view(...)

Data descriptors inherited from generic:
T
transpose
__array_interface__
Array protocol: Python side
__array_priority__
Array priority.
__array_struct__
Array protocol: struct
base
base object
data
pointer to start of data
dtype
get array data-descriptor
flags
integer value of flags
flat
a 1-d view of scalar
imag
imaginary part of scalar
itemsize
length of one element in bytes
nbytes
length of item in bytes
ndim
number of array dimensions
real
real part of scalar
shape
tuple of array dimensions
size
number of elements in the gentype
strides
tuple of bytes steps in each dimension

 
class uint16(unsignedinteger)
    
Method resolution order:
uint16
unsignedinteger
integer
number
generic
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 at 0x7f8ebc33b1c0>
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
__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__(...)
__str__(...)
x.__str__() <==> str(x)
__sub__(...)
x.__sub__(y) <==> x-y
__truediv__(...)
x.__truediv__(y) <==> x/y
__xor__(...)
x.__xor__(y) <==> x^y
all(...)
any(...)
argmax(...)
argmin(...)
argsort(...)
astype(...)
byteswap(...)
choose(...)
clip(...)
compress(...)
conj(...)
conjugate(...)
copy(...)
cumprod(...)
cumsum(...)
diagonal(...)
dump(...)
dumps(...)
fill(...)
flatten(...)
getfield(...)
item(...)
itemset(...)
max(...)
mean(...)
min(...)
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:
 
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
 
Parameters
----------
new_order : string, 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(...)
prod(...)
ptp(...)
put(...)
ravel(...)
repeat(...)
reshape(...)
resize(...)
round(...)
searchsorted(...)
setfield(...)
setflags(...)
sort(...)
squeeze(...)
std(...)
sum(...)
swapaxes(...)
take(...)
tofile(...)
tolist(...)
tostring(...)
trace(...)
transpose(...)
var(...)
view(...)

Data descriptors inherited from generic:
T
transpose
__array_interface__
Array protocol: Python side
__array_priority__
Array priority.
__array_struct__
Array protocol: struct
base
base object
data
pointer to start of data
dtype
get array data-descriptor
flags
integer value of flags
flat
a 1-d view of scalar
imag
imaginary part of scalar
itemsize
length of one element in bytes
nbytes
length of item in bytes
ndim
number of array dimensions
real
real part of scalar
shape
tuple of array dimensions
size
number of elements in the gentype
strides
tuple of bytes steps in each dimension

 
class uint32(unsignedinteger)
    
Method resolution order:
uint32
unsignedinteger
integer
number
generic
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 at 0x7f8ebc33b360>
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
__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__(...)
__str__(...)
x.__str__() <==> str(x)
__sub__(...)
x.__sub__(y) <==> x-y
__truediv__(...)
x.__truediv__(y) <==> x/y
__xor__(...)
x.__xor__(y) <==> x^y
all(...)
any(...)
argmax(...)
argmin(...)
argsort(...)
astype(...)
byteswap(...)
choose(...)
clip(...)
compress(...)
conj(...)
conjugate(...)
copy(...)
cumprod(...)
cumsum(...)
diagonal(...)
dump(...)
dumps(...)
fill(...)
flatten(...)
getfield(...)
item(...)
itemset(...)
max(...)
mean(...)
min(...)
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:
 
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
 
Parameters
----------
new_order : string, 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(...)
prod(...)
ptp(...)
put(...)
ravel(...)
repeat(...)
reshape(...)
resize(...)
round(...)
searchsorted(...)
setfield(...)
setflags(...)
sort(...)
squeeze(...)
std(...)
sum(...)
swapaxes(...)
take(...)
tofile(...)
tolist(...)
tostring(...)
trace(...)
transpose(...)
var(...)
view(...)

Data descriptors inherited from generic:
T
transpose
__array_interface__
Array protocol: Python side
__array_priority__
Array priority.
__array_struct__
Array protocol: struct
base
base object
data
pointer to start of data
dtype
get array data-descriptor
flags
integer value of flags
flat
a 1-d view of scalar
imag
imaginary part of scalar
itemsize
length of one element in bytes
nbytes
length of item in bytes
ndim
number of array dimensions
real
real part of scalar
shape
tuple of array dimensions
size
number of elements in the gentype
strides
tuple of bytes steps in each dimension

 
class uint64(unsignedinteger)
    
Method resolution order:
uint64
unsignedinteger
integer
number
generic
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 at 0x7f8ebc33b500>
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
__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__(...)
__str__(...)
x.__str__() <==> str(x)
__sub__(...)
x.__sub__(y) <==> x-y
__truediv__(...)
x.__truediv__(y) <==> x/y
__xor__(...)
x.__xor__(y) <==> x^y
all(...)
any(...)
argmax(...)
argmin(...)
argsort(...)
astype(...)
byteswap(...)
choose(...)
clip(...)
compress(...)
conj(...)
conjugate(...)
copy(...)
cumprod(...)
cumsum(...)
diagonal(...)
dump(...)
dumps(...)
fill(...)
flatten(...)
getfield(...)
item(...)
itemset(...)
max(...)
mean(...)
min(...)
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:
 
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
 
Parameters
----------
new_order : string, 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(...)
prod(...)
ptp(...)
put(...)
ravel(...)
repeat(...)
reshape(...)
resize(...)
round(...)
searchsorted(...)
setfield(...)
setflags(...)
sort(...)
squeeze(...)
std(...)
sum(...)
swapaxes(...)
take(...)
tofile(...)
tolist(...)
tostring(...)
trace(...)
transpose(...)
var(...)
view(...)

Data descriptors inherited from generic:
T
transpose
__array_interface__
Array protocol: Python side
__array_priority__
Array priority.
__array_struct__
Array protocol: struct
base
base object
data
pointer to start of data
dtype
get array data-descriptor
flags
integer value of flags
flat
a 1-d view of scalar
imag
imaginary part of scalar
itemsize
length of one element in bytes
nbytes
length of item in bytes
ndim
number of array dimensions
real
real part of scalar
shape
tuple of array dimensions
size
number of elements in the gentype
strides
tuple of bytes steps in each dimension

 
class uint8(unsignedinteger)
    
Method resolution order:
uint8
unsignedinteger
integer
number
generic
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 at 0x7f8ebc33b020>
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
__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__(...)
__str__(...)
x.__str__() <==> str(x)
__sub__(...)
x.__sub__(y) <==> x-y
__truediv__(...)
x.__truediv__(y) <==> x/y
__xor__(...)
x.__xor__(y) <==> x^y
all(...)
any(...)
argmax(...)
argmin(...)
argsort(...)
astype(...)
byteswap(...)
choose(...)
clip(...)
compress(...)
conj(...)
conjugate(...)
copy(...)
cumprod(...)
cumsum(...)
diagonal(...)
dump(...)
dumps(...)
fill(...)
flatten(...)
getfield(...)
item(...)
itemset(...)
max(...)
mean(...)
min(...)
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:
 
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
 
Parameters
----------
new_order : string, 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(...)
prod(...)
ptp(...)
put(...)
ravel(...)
repeat(...)
reshape(...)
resize(...)
round(...)
searchsorted(...)
setfield(...)
setflags(...)
sort(...)
squeeze(...)
std(...)
sum(...)
swapaxes(...)
take(...)
tofile(...)
tolist(...)
tostring(...)
trace(...)
transpose(...)
var(...)
view(...)

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

 
uintc = class uint32(unsignedinteger)
    
Method resolution order:
uint32
unsignedinteger
integer
number
generic
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 at 0x7f8ebc33b360>
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
__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__(...)
__str__(...)
x.__str__() <==> str(x)
__sub__(...)
x.__sub__(y) <==> x-y
__truediv__(...)
x.__truediv__(y) <==> x/y
__xor__(...)
x.__xor__(y) <==> x^y
all(...)
any(...)
argmax(...)
argmin(...)
argsort(...)
astype(...)
byteswap(...)
choose(...)
clip(...)
compress(...)
conj(...)
conjugate(...)
copy(...)
cumprod(...)
cumsum(...)
diagonal(...)
dump(...)
dumps(...)
fill(...)
flatten(...)
getfield(...)
item(...)
itemset(...)
max(...)
mean(...)
min(...)
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:
 
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
 
Parameters
----------
new_order : string, 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(...)
prod(...)
ptp(...)
put(...)
ravel(...)
repeat(...)
reshape(...)
resize(...)
round(...)
searchsorted(...)
setfield(...)
setflags(...)
sort(...)
squeeze(...)
std(...)
sum(...)
swapaxes(...)
take(...)
tofile(...)
tolist(...)
tostring(...)
trace(...)
transpose(...)
var(...)
view(...)

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
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 at 0x7f8ebc33b500>
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
__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__(...)
__str__(...)
x.__str__() <==> str(x)
__sub__(...)
x.__sub__(y) <==> x-y
__truediv__(...)
x.__truediv__(y) <==> x/y
__xor__(...)
x.__xor__(y) <==> x^y
all(...)
any(...)
argmax(...)
argmin(...)
argsort(...)
astype(...)
byteswap(...)
choose(...)
clip(...)
compress(...)
conj(...)
conjugate(...)
copy(...)
cumprod(...)
cumsum(...)
diagonal(...)
dump(...)
dumps(...)
fill(...)
flatten(...)
getfield(...)
item(...)
itemset(...)
max(...)
mean(...)
min(...)
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:
 
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
 
Parameters
----------
new_order : string, 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(...)
prod(...)
ptp(...)
put(...)
ravel(...)
repeat(...)
reshape(...)
resize(...)
round(...)
searchsorted(...)
setfield(...)
setflags(...)
sort(...)
squeeze(...)
std(...)
sum(...)
swapaxes(...)
take(...)
tofile(...)
tolist(...)
tostring(...)
trace(...)
transpose(...)
var(...)
view(...)

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
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 at 0x7f8ebc33b6a0>
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
__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__(...)
__str__(...)
x.__str__() <==> str(x)
__sub__(...)
x.__sub__(y) <==> x-y
__truediv__(...)
x.__truediv__(y) <==> x/y
__xor__(...)
x.__xor__(y) <==> x^y
all(...)
any(...)
argmax(...)
argmin(...)
argsort(...)
astype(...)
byteswap(...)
choose(...)
clip(...)
compress(...)
conj(...)
conjugate(...)
copy(...)
cumprod(...)
cumsum(...)
diagonal(...)
dump(...)
dumps(...)
fill(...)
flatten(...)
getfield(...)
item(...)
itemset(...)
max(...)
mean(...)
min(...)
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:
 
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
 
Parameters
----------
new_order : string, 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(...)
prod(...)
ptp(...)
put(...)
ravel(...)
repeat(...)
reshape(...)
resize(...)
round(...)
searchsorted(...)
setfield(...)
setflags(...)
sort(...)
squeeze(...)
std(...)
sum(...)
swapaxes(...)
take(...)
tofile(...)
tolist(...)
tostring(...)
trace(...)
transpose(...)
var(...)
view(...)

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_(unicode, character)
    
Method resolution order:
unicode_
unicode
basestring
character
flexible
generic
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 at 0x7f8ebc33c540>
T.__new__(S, ...) -> a new object with type S, a subtype of T

Methods inherited from unicode:
__add__(...)
x.__add__(y) <==> x+y
__contains__(...)
x.__contains__(y) <==> y in x
__format__(...)
S.__format__(format_spec) -> unicode
__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.
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 registerd 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
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(sequence) -> unicode
 
Return a string which is the concatenation of the strings in the
sequence.  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) -> (tail, sep, head)
 
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]) -> 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(...)
any(...)
argmax(...)
argmin(...)
argsort(...)
astype(...)
byteswap(...)
choose(...)
clip(...)
compress(...)
conj(...)
conjugate(...)
copy(...)
cumprod(...)
cumsum(...)
diagonal(...)
dump(...)
dumps(...)
fill(...)
flatten(...)
getfield(...)
item(...)
itemset(...)
max(...)
mean(...)
min(...)
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:
 
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
 
Parameters
----------
new_order : string, 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(...)
prod(...)
ptp(...)
put(...)
ravel(...)
repeat(...)
reshape(...)
resize(...)
round(...)
searchsorted(...)
setfield(...)
setflags(...)
sort(...)
squeeze(...)
std(...)
sum(...)
swapaxes(...)
take(...)
tofile(...)
tolist(...)
tostring(...)
trace(...)
transpose(...)
var(...)
view(...)

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_(unicode, character)
    
Method resolution order:
unicode_
unicode
basestring
character
flexible
generic
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 at 0x7f8ebc33c540>
T.__new__(S, ...) -> a new object with type S, a subtype of T

Methods inherited from unicode:
__add__(...)
x.__add__(y) <==> x+y
__contains__(...)
x.__contains__(y) <==> y in x
__format__(...)
S.__format__(format_spec) -> unicode
__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.
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 registerd 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
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(sequence) -> unicode
 
Return a string which is the concatenation of the strings in the
sequence.  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) -> (tail, sep, head)
 
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]) -> 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(...)
any(...)
argmax(...)
argmin(...)
argsort(...)
astype(...)
byteswap(...)
choose(...)
clip(...)
compress(...)
conj(...)
conjugate(...)
copy(...)
cumprod(...)
cumsum(...)
diagonal(...)
dump(...)
dumps(...)
fill(...)
flatten(...)
getfield(...)
item(...)
itemset(...)
max(...)
mean(...)
min(...)
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:
 
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
 
Parameters
----------
new_order : string, 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(...)
prod(...)
ptp(...)
put(...)
ravel(...)
repeat(...)
reshape(...)
resize(...)
round(...)
searchsorted(...)
setfield(...)
setflags(...)
sort(...)
squeeze(...)
std(...)
sum(...)
swapaxes(...)
take(...)
tofile(...)
tolist(...)
tostring(...)
trace(...)
transpose(...)
var(...)
view(...)

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
object

Methods inherited from generic:
__abs__(...)
x.__abs__() <==> abs(x)
__add__(...)
x.__add__(y) <==> x+y
__and__(...)
x.__and__(y) <==> x&y
__array__(...)
sc.__array__(|type) return 0-dim array
__array_wrap__(...)
sc.__array_wrap__(obj) return scalar from array
__copy__(...)
__deepcopy__(...)
__div__(...)
x.__div__(y) <==> x/y
__divmod__(...)
x.__divmod__(y) <==> divmod(x, y)
__eq__(...)
x.__eq__(y) <==> x==y
__float__(...)
x.__float__() <==> float(x)
__floordiv__(...)
x.__floordiv__(y) <==> x//y
__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__(...)
__str__(...)
x.__str__() <==> str(x)
__sub__(...)
x.__sub__(y) <==> x-y
__truediv__(...)
x.__truediv__(y) <==> x/y
__xor__(...)
x.__xor__(y) <==> x^y
all(...)
any(...)
argmax(...)
argmin(...)
argsort(...)
astype(...)
byteswap(...)
choose(...)
clip(...)
compress(...)
conj(...)
conjugate(...)
copy(...)
cumprod(...)
cumsum(...)
diagonal(...)
dump(...)
dumps(...)
fill(...)
flatten(...)
getfield(...)
item(...)
itemset(...)
max(...)
mean(...)
min(...)
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:
 
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
 
Parameters
----------
new_order : string, 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(...)
prod(...)
ptp(...)
put(...)
ravel(...)
repeat(...)
reshape(...)
resize(...)
round(...)
searchsorted(...)
setfield(...)
setflags(...)
sort(...)
squeeze(...)
std(...)
sum(...)
swapaxes(...)
take(...)
tofile(...)
tolist(...)
tostring(...)
trace(...)
transpose(...)
var(...)
view(...)

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
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 at 0x7f8ebc33b1c0>
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
__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__(...)
__str__(...)
x.__str__() <==> str(x)
__sub__(...)
x.__sub__(y) <==> x-y
__truediv__(...)
x.__truediv__(y) <==> x/y
__xor__(...)
x.__xor__(y) <==> x^y
all(...)
any(...)
argmax(...)
argmin(...)
argsort(...)
astype(...)
byteswap(...)
choose(...)
clip(...)
compress(...)
conj(...)
conjugate(...)
copy(...)
cumprod(...)
cumsum(...)
diagonal(...)
dump(...)
dumps(...)
fill(...)
flatten(...)
getfield(...)
item(...)
itemset(...)
max(...)
mean(...)
min(...)
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:
 
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
 
Parameters
----------
new_order : string, 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(...)
prod(...)
ptp(...)
put(...)
ravel(...)
repeat(...)
reshape(...)
resize(...)
round(...)
searchsorted(...)
setfield(...)
setflags(...)
sort(...)
squeeze(...)
std(...)
sum(...)
swapaxes(...)
take(...)
tofile(...)
tolist(...)
tostring(...)
trace(...)
transpose(...)
var(...)
view(...)

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 void(flexible)
    
Method resolution order:
void
flexible
generic
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 at 0x7f8ebc33c6e0>
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
__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__(...)
__str__(...)
x.__str__() <==> str(x)
__sub__(...)
x.__sub__(y) <==> x-y
__truediv__(...)
x.__truediv__(y) <==> x/y
__xor__(...)
x.__xor__(y) <==> x^y
all(...)
any(...)
argmax(...)
argmin(...)
argsort(...)
astype(...)
byteswap(...)
choose(...)
clip(...)
compress(...)
conj(...)
conjugate(...)
copy(...)
cumprod(...)
cumsum(...)
diagonal(...)
dump(...)
dumps(...)
fill(...)
flatten(...)
item(...)
itemset(...)
max(...)
mean(...)
min(...)
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:
 
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
 
Parameters
----------
new_order : string, 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(...)
prod(...)
ptp(...)
put(...)
ravel(...)
repeat(...)
reshape(...)
resize(...)
round(...)
searchsorted(...)
setflags(...)
sort(...)
squeeze(...)
std(...)
sum(...)
swapaxes(...)
take(...)
tofile(...)
tolist(...)
tostring(...)
trace(...)
transpose(...)
var(...)
view(...)

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
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 at 0x7f8ebc33c6e0>
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
__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__(...)
__str__(...)
x.__str__() <==> str(x)
__sub__(...)
x.__sub__(y) <==> x-y
__truediv__(...)
x.__truediv__(y) <==> x/y
__xor__(...)
x.__xor__(y) <==> x^y
all(...)
any(...)
argmax(...)
argmin(...)
argsort(...)
astype(...)
byteswap(...)
choose(...)
clip(...)
compress(...)
conj(...)
conjugate(...)
copy(...)
cumprod(...)
cumsum(...)
diagonal(...)
dump(...)
dumps(...)
fill(...)
flatten(...)
item(...)
itemset(...)
max(...)
mean(...)
min(...)
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:
 
* {'<', 'L'} - little endian
* {'>', 'B'} - big endian
* {'=', 'N'} - native order
* 'S' - swap dtype from current to opposite endian
* {'|', 'I'} - ignore (no change to byte order)
 
Parameters
----------
new_order : string, 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(...)
prod(...)
ptp(...)
put(...)
ravel(...)
repeat(...)
reshape(...)
resize(...)
round(...)
searchsorted(...)
setflags(...)
sort(...)
squeeze(...)
std(...)
sum(...)
swapaxes(...)
take(...)
tofile(...)
tolist(...)
tostring(...)
trace(...)
transpose(...)
var(...)
view(...)

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(...)
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
alterdot(...)
Change `dot`, `vdot`, and `innerproduct` 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 float32float64complex64, 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.
 
See Also
--------
restoredot : `restoredot` undoes the effects of `alterdot`.
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 a ndarray rather than a list.
 
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.
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
-------
out : 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])
array(...)
array(objectdtype=None, copy=True, order=None, subok=False, ndmin=True)
 
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' (default), 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', then the returned array may
    be in any order (either C-, Fortran-contiguous, or even
    discontiguous).
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.
 
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]])
bincount(...)
bincount(x, weights=None)
 
Return the number of occurrences of each value in array of nonnegative
integers.
 
The output, b[i], represents the number of times that i is found in `x`.
If `weights` is specified, every occurrence of i at a position p
contributes `weights` [p] instead of 1.
 
Parameters
----------
x : array_like, 1 dimension, nonnegative integers
    Input array.
weights : array_like, same shape as `x`, optional
    Weights.
 
See Also
--------
histogram, digitize, unique
can_cast(...)
can_cast(from=d1, to=d2)
 
Returns True if cast between data types can occur without losing precision.
 
Parameters
----------
from: data type code
    Data type code to cast from.
to: data type code
    Data type code to cast to.
 
Returns
-------
out : bool
    True if cast can occur without losing precision.
compare_chararrays(...)
concatenate(...)
concatenate((a1, a2, ...), axis=0)
 
Join a sequence of arrays together.
 
Parameters
----------
a1, a2, ... : sequence of ndarrays
    The arrays must have the same shape, except in the dimension
    corresponding to `axis` (the first, by default).
axis : int, optional
    The axis along which the arrays will be joined.  Default is 0.
 
Returns
-------
res : ndarray
    The concatenated array.
 
See Also
--------
array_split : Split an array into multiple sub-arrays of equal or
              near-equal size.
split : Split array into a list of multiple sub-arrays of equal size.
hsplit : Split array into multiple sub-arrays horizontally (column wise)
vsplit : Split array into multiple sub-arrays vertically (row wise)
dsplit : Split array into multiple sub-arrays along the 3rd axis (depth).
hstack : Stack arrays in sequence horizontally (column wise)
vstack : Stack arrays in sequence vertically (row wise)
dstack : Stack arrays in sequence depth wise (along third dimension)
 
Examples
--------
>>> a = np.array([[1, 2], [3, 4]])
>>> b = np.array([[5, 6]])
>>> np.concatenate((a, b), axis=0)
array([[1, 2],
       [3, 4],
       [5, 6]])
>>> np.concatenate((a, b.T), axis=1)
array([[1, 2, 5],
       [3, 4, 6]])
digitize(...)
digitize(x, bins)
 
Return the indices of the bins to which each value in input array belongs.
 
Each index returned is such that `bins[i-1]` <= `x` < `bins[i]` if `bins`
is monotonically increasing, or `bins[i-1]` > `x` >= `bins[i]` if `bins`
is monotonically decreasing. Beyond the bounds of `bins`, 0 or len(`bins`)
is returned as appropriate.
 
Parameters
----------
x : array_like
    Input array to be binned.
bins : array_like
    Array of bins.
 
Returns
-------
out : ndarray
    Output array of indices of same shape as `x`.
 
Examples
--------
>>> x = np.array([0.2, 6.4, 3.0, 1.6])
>>> bins = np.array([0.0, 1.0, 2.5, 4.0, 10.0])
>>> d = np.digitize(x,bins)
>>> d
array([1, 4, 3, 2])
>>> for n in range(len(x)):
...   print bins[d[n]-1], "<=", x[n], "<", bins[d[n]]
...
0.0 <= 0.2 < 1.0
4.0 <= 6.4 < 10.0
2.5 <= 3.0 < 4.0
1.0 <= 1.6 < 2.5
dot(...)
dot(a, b)
 
Dot product of two arrays.
 
For 2-D arrays it is equivalent to matrix multiplication, and for 1-D
arrays to inner product of vectors (without complex conjugation). For
N dimensions it is a sum product over the last axis of `a` and
the second-to-last of `b`::
 
    dot(a, b)[i,j,k,m] = sum(a[i,j,:] * b[k,:,m])
 
Parameters
----------
a : array_like
    First argument.
b : array_like
    Second argument.
 
Returns
-------
output : ndarray
    Returns the dot product of `a` and `b`.  If `a` and `b` are both
    scalars or both 1-D arrays then a scalar is returned; otherwise
    an array is returned.
 
Raises
------
ValueError
    If the last dimension of `a` is not the same size as
    the second-to-last dimension of `b`.
 
See Also
--------
vdot : Complex-conjugating dot product.
tensordot : Sum products over arbitrary axes.
 
Examples
--------
>>> np.dot(3, 4)
12
 
Neither argument is complex-conjugated:
 
>>> np.dot([2j, 3j], [2j, 3j])
(-13+0j)
 
For 2-D arrays it's the matrix product:
 
>>> a = [[1, 0], [0, 1]]
>>> b = [[4, 1], [2, 2]]
>>> np.dot(a, b)
array([[4, 1],
       [2, 2]])
 
>>> a = np.arange(3*4*5*6).reshape((3,4,5,6))
>>> b = np.arange(3*4*5*6)[::-1].reshape((5,4,6,3))
>>> np.dot(a, b)[2,3,2,1,2,2]
499128
>>> sum(a[2,3,2,:] * b[1,2,:,2])
499128
empty(...)
empty(shape, dtype=float, order='C')
 
Return a new array of given shape and type, without initialising entries.
 
Parameters
----------
shape : {tuple of intint}
    Shape of the empty array
dtype : data-type, optional
    Desired output data-type.
order : {'C', 'F'}, optional
    Whether to store multi-dimensional data in C (row-major) or
    Fortran (column-major) order in memory.
 
See Also
--------
empty_like, zeros
 
Notes
-----
`empty`, unlike `zeros`, does not set the array values to zero,
and may therefore be marginally faster.  On the other hand, it requires
the user to manually set all the values in the array, and should be
used with caution.
 
Examples
--------
>>> np.empty([2, 2])
array([[ -9.74499359e+001,   6.69583040e-309],  #random data
       [  2.13182611e-314,   3.06959433e-309]])
 
>>> np.empty([2, 2], dtype=int)
array([[-1073741821, -1067949133],  #random data
       [  496041986,    19249760]])
fastCopyAndTranspose = _fastCopyAndTranspose(...)
_fastCopyAndTranspose(a)
frombuffer(...)
frombuffer(buffer, dtype=float, count=-1, offset=0)
 
Interpret a buffer as a 1-dimensional array.
 
Parameters
----------
buffer
    An object that exposes the buffer interface.
dtype : data-type, optional
    Data type of the returned array.
count : int, optional
    Number of items to read. ``-1`` means all data in the buffer.
offset : int, optional
    Start reading the buffer from this offset.
 
Notes
-----
If the buffer has data that is not in machine byte-order, this
should be specified as part of the data-type, e.g.::
 
  >>> dt = np.dtype(int)
  >>> dt = dt.newbyteorder('>')
  >>> np.frombuffer(buf, dtype=dt)
 
The data of the resulting array will not be byteswapped,
but will be interpreted correctly.
 
Examples
--------
>>> s = 'hello world'
>>> np.frombuffer(s, dtype='S1', count=5, offset=6)
array(['w', 'o', 'r', 'l', 'd'],
      dtype='|S1')
fromfile(...)
fromfile(file, dtype=float, count=-1, sep='')
 
Construct an array from data in a text or binary file.
 
A highly efficient way of reading binary data with a known data-type,
as well as parsing simply formatted text files.  Data written using the
`tofile` method can be read using this function.
 
Parameters
----------
file : file or string
    Open file object or filename.
dtype : data-type
    Data type of the returned array.
    For binary files, it is used to determine the size and byte-order
    of the items in the file.
count : int
    Number of items to read. ``-1`` means all items (i.e., the complete
    file).
sep : string
    Separator between items if file is a text file.
    Empty ("") separator means the file should be treated as binary.
    Spaces (" ") in the separator match zero or more whitespace characters.
    A separator consisting only of spaces must match at least one
    whitespace.
 
See also
--------
load, save
ndarray.tofile
loadtxt : More flexible way of loading data from a text file.
 
Notes
-----
Do not rely on the combination of `tofile` and `fromfile` for
data storage, as the binary files generated are are not platform
independent.  In particular, no byte-order or data-type information is
saved.  Data can be stored in the platform independent ``.npy`` format
using `save` and `load` instead.
 
Examples
--------
Construct an ndarray:
 
>>> dt = np.dtype([('time', [('min', int), ('sec', int)]),
...                ('temp', float)])
>>> x = np.zeros((1,), dtype=dt)
>>> x['time']['min'] = 10; x['temp'] = 98.25
>>> x
array([((10, 0), 98.25)],
      dtype=[('time', [('min', '<i4'), ('sec', '<i4')]), ('temp', '<f8')])
 
Save the raw data to disk:
 
>>> import os
>>> fname = os.tmpnam()
>>> x.tofile(fname)
 
Read the raw data from disk:
 
>>> np.fromfile(fname, dtype=dt)
array([((10, 0), 98.25)],
      dtype=[('time', [('min', '<i4'), ('sec', '<i4')]), ('temp', '<f8')])
 
The recommended way to store and load data:
 
>>> np.save(fname, x)
>>> np.load(fname + '.npy')
array([((10, 0), 98.25)],
      dtype=[('time', [('min', '<i4'), ('sec', '<i4')]), ('temp', '<f8')])
fromiter(...)
fromiter(iterable, dtype, count=-1)
 
Create a new 1-dimensional array from an iterable object.
 
Parameters
----------
iterable : iterable object
    An iterable object providing data for the array.
dtype : data-type
    The data type of the returned array.
count : int, optional
    The number of items to read from iterable. The default is -1,
    which means all data is read.
 
Returns
-------
out : ndarray
    The output array.
 
Notes
-----
Specify ``count`` to improve performance.  It allows
``fromiter`` to pre-allocate the output array, instead of
resizing it on demand.
 
Examples
--------
>>> iterable = (x*x for x in range(5))
>>> np.fromiter(iterable, np.float)
array([  0.,   1.,   4.,   9.,  16.])
frompyfunc(...)
frompyfunc(func, nin, nout) take an arbitrary python
function that takes nin objects as input and returns
nout objects and return a universal function (ufunc).
This ufunc always returns PyObject arrays
fromstring(...)
fromstring(string, dtype=float, count=-1, sep='')
 
Return a new 1d array initialized from raw binary or text data in
string.
 
Parameters
----------
string : str
    A string containing the data.
dtype : dtype, optional
    The data type of the array. For binary input data, the data must be
    in exactly this format.
count : int, optional
    Read this number of `dtype` elements from the data. If this is
    negative, then the size will be determined from the length of the
    data.
sep : str, optional
    If provided and not empty, then the data will be interpreted as
    ASCII text with decimal numbers. This argument is interpreted as the
    string separating numbers in the data. Extra whitespace between
    elements is also ignored.
 
Returns
-------
arr : array
    The constructed array.
 
Raises
------
ValueError
    If the string is not the correct size to satisfy the requested
    `dtype` and `count`.
 
Examples
--------
>>> np.fromstring('\x01\x02', dtype=np.uint8)
array([1, 2], dtype=uint8)
>>> np.fromstring('1 2', dtype=int, sep=' ')
array([1, 2])
>>> np.fromstring('1, 2', dtype=int, sep=',')
array([1, 2])
>>> np.fromstring('\x01\x02\x03\x04\x05', dtype=np.uint8, count=3)
array([1, 2, 3], dtype=uint8)
 
Invalid inputs:
 
>>> np.fromstring('\x01\x02\x03\x04\x05', dtype=np.int32)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: string size must be a multiple of element size
>>> np.fromstring('\x01\x02', dtype=np.uint8, count=3)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: string is smaller than requested size
getbuffer(...)
getbuffer(obj [,offset[, size]])
 
Create a buffer object from the given object referencing a slice of
length size starting at offset.  Default is the entire buffer. A
read-write buffer is attempted followed by a read-only buffer.
geterrobj(...)
geterrobj()
 
Used internally by `geterr`.
 
Returns
-------
errobj : list
    Internal numpy buffer size, error mask, error callback function.
inner(...)
inner(a, b)
 
Inner product of two arrays.
 
Ordinary inner product of vectors for 1-D arrays (without complex
conjugation), in higher dimensions a sum product over the last axes.
 
Parameters
----------
a, b : array_like
    If `a` and `b` are nonscalar, their last dimensions of must match.
 
Returns
-------
out : ndarray
    `out.shape = a.shape[:-1] + b.shape[:-1]`
 
Raises
------
ValueError
    If the last dimension of `a` and `b` has different size.
 
See Also
--------
tensordot : Sum products over arbitrary axes.
dot : Generalised matrix product, using second last dimension of `b`.
 
Notes
-----
For vectors (1-D arrays) it computes the ordinary inner-product::
 
    np.inner(a, b) = sum(a[:]*b[:])
 
More generally, if `ndim(a) = r > 0` and `ndim(b) = s > 0`::
 
    np.inner(a, b) = np.tensordot(a, b, axes=(-1,-1))
 
or explicitly::
 
    np.inner(a, b)[i0,...,ir-1,j0,...,js-1]
         = sum(a[i0,...,ir-1,:]*b[j0,...,js-1,:])
 
In addition `a` or `b` may be scalars, in which case::
 
   np.inner(a,b) = a*b
 
Examples
--------
Ordinary inner product for vectors:
 
>>> a = np.array([1,2,3])
>>> b = np.array([0,1,0])
>>> np.inner(a, b)
2
 
A multidimensional example:
 
>>> a = np.arange(24).reshape((2,3,4))
>>> b = np.arange(4)
>>> np.inner(a, b)
array([[ 14,  38,  62],
       [ 86, 110, 134]])
 
An example where `b` is a scalar:
 
>>> np.inner(np.eye(2), 7)
array([[ 7.,  0.],
       [ 0.,  7.]])
int_asbuffer(...)
lexsort(...)
lexsort(keys, axis=-1)
 
Perform an indirect sort using a sequence of keys.
 
Given multiple sorting keys, which can be interpreted as columns in a
spreadsheet, lexsort returns an array of integer indices that describes
the sort order by multiple columns. The last key in the sequence is used
for the primary sort order, the second-to-last key for the secondary sort
order, and so on. The keys argument must be a sequence of objects that
can be converted to arrays of the same shape. If a 2D array is provided
for the keys argument, it's rows are interpreted as the sorting keys and
sorting is according to the last row, second last row etc.
 
Parameters
----------
keys : (k,N) array or tuple containing k (N,)-shaped sequences
    The `k` different "columns" to be sorted.  The last column (or row if
    `keys` is a 2D array) is the primary sort key.
axis : int, optional
    Axis to be indirectly sorted.  By default, sort over the last axis.
 
Returns
-------
indices : (N,) ndarray of ints
    Array of indices that sort the keys along the specified axis.
 
See Also
--------
argsort : Indirect sort.
ndarray.sort : In-place sort.
sort : Return a sorted copy of an array.
 
Examples
--------
Sort names: first by surname, then by name.
 
>>> surnames =    ('Hertz',    'Galilei', 'Hertz')
>>> first_names = ('Heinrich', 'Galileo', 'Gustav')
>>> ind = np.lexsort((first_names, surnames))
>>> ind
array([1, 2, 0])
 
>>> [surnames[i] + ", " + first_names[i] for i in ind]
['Galilei, Galileo', 'Hertz, Gustav', 'Hertz, Heinrich']
 
Sort two columns of numbers:
 
>>> a = [1,5,1,4,3,4,4] # First column
>>> b = [9,4,0,4,0,2,1] # Second column
>>> ind = np.lexsort((b,a)) # Sort by a, then by b
>>> print ind
[2 0 4 6 5 3 1]
 
>>> [(a[i],b[i]) for i in ind]
[(1, 0), (1, 9), (3, 0), (4, 1), (4, 2), (4, 4), (5, 4)]
 
Note that sorting is first according to the elements of ``a``.
Secondary sorting is according to the elements of ``b``.
 
A normal ``argsort`` would have yielded:
 
>>> [(a[i],b[i]) for i in np.argsort(a)]
[(1, 9), (1, 0), (3, 0), (4, 4), (4, 2), (4, 1), (5, 4)]
 
Structured arrays are sorted lexically by ``argsort``:
 
>>> x = np.array([(1,9), (5,4), (1,0), (4,4), (3,0), (4,2), (4,1)],
...              dtype=np.dtype([('x', int), ('y', int)]))
 
>>> np.argsort(x) # or np.argsort(x, order=('x', 'y'))
array([2, 0, 4, 6, 5, 3, 1])
loads(...)
loads(string) -- Load a pickle from the given string
newbuffer(...)
newbuffer(size)
 
Return a new uninitialized buffer object of size bytes
packbits(...)
packbits(myarray, axis=None)
 
Packs the elements of a binary-valued array into bits in a uint8 array.
 
The result is padded to full bytes by inserting zero bits at the end.
 
Parameters
----------
myarray : array_like
    An integer type array whose elements should be packed to bits.
axis : int, optional
    The dimension over which bit-packing is done.
    ``None`` implies packing the flattened array.
 
Returns
-------
packed : ndarray
    Array of type uint8 whose elements represent bits corresponding to the
    logical (0 or nonzero) value of the input elements. The shape of
    `packed` has the same number of dimensions as the input (unless `axis`
    is None, in which case the output is 1-D).
 
See Also
--------
unpackbits: Unpacks elements of a uint8 array into a binary-valued output
            array.
 
Examples
--------
>>> a = np.array([[[1,0,1],
...                [0,1,0]],
...               [[1,1,0],
...                [0,0,1]]])
>>> b = np.packbits(a, axis=-1)
>>> b
array([[[160],[64]],[[192],[32]]], dtype=uint8)
 
Note that in binary 160 = 1010 0000, 64 = 0100 0000, 192 = 1100 0000,
and 32 = 0010 0000.
pkgload(*packages, **options)
Load one or more packages into parent package top-level namespace.
 
This function is intended to shorten the need to import many
subpackages, say of scipy, constantly with statements such as
 
  import scipy.linalg, scipy.fftpack, scipy.etc...
 
Instead, you can say:
 
  import scipy
  scipy.pkgload('linalg','fftpack',...)
 
or
 
  scipy.pkgload()
 
to load all of them in one call.
 
If a name which doesn't exist in scipy's namespace is
given, a warning is shown.
 
Parameters
----------
 *packages : arg-tuple
      the names (one or more strings) of all the modules one
      wishes to load into the top-level namespace.
 verbose= : integer
      verbosity level [default: -1].
      verbose=-1 will suspend also warnings.
 force= : bool
      when True, force reloading loaded packages [default: False].
 postpone= : bool
      when True, don't load packages [default: False]
putmask(...)
putmask(a, mask, values)
 
Changes elements of an array based on conditional and input values.
 
Sets ``a.flat[n] = values[n]`` for each n where ``mask.flat[n]==True``.
 
If `values` is not the same size as `a` and `mask` then it will repeat.
This gives behavior different from ``a[mask] = values``.
 
Parameters
----------
a : array_like
    Target array.
mask : array_like
    Boolean mask array. It has to be the same shape as `a`.
values : array_like
    Values to put into `a` where `mask` is True. If `values` is smaller
    than `a` it will be repeated.
 
See Also
--------
place, put, take
 
Examples
--------
>>> x = np.arange(6).reshape(2, 3)
>>> np.putmask(x, x>2, x**2)
>>> x
array([[ 0,  1,  2],
       [ 9, 16, 25]])
 
If `values` is smaller than `a` it is repeated:
 
>>> x = np.arange(5)
>>> np.putmask(x, x>1, [-33, -44])
>>> x
array([  0,   1, -33, -44, -33])
restoredot(...)
Restore `dot`, `vdot`, and `innerproduct` to the default non-BLAS
implementations.
 
Typically, the user will only need to call this when troubleshooting and
installation problem, reproducing the conditions of a build without an
accelerated BLAS, or when being very careful about benchmarking linear
algebra operations.
 
See Also
--------
alterdot : `restoredot` undoes the effects of `alterdot`.
set_numeric_ops(...)
set_numeric_ops(op1=func1, op2=func2, ...)
 
Set numerical operators for array objects.
 
Parameters
----------
op1, op2, ... : callable
    Each ``op = func`` pair describes an operator to be replaced.
    For example, ``add = lambda x, y: np.add(x, y) % 5`` would replace
    addition by modulus 5 addition.
 
Returns
-------
saved_ops : list of callables
    A list of all operators, stored before making replacements.
 
Notes
-----
.. WARNING::
   Use with care!  Incorrect usage may lead to memory errors.
 
A function replacing an operator cannot make use of that operator.
For example, when replacing add, you may not use ``+``.  Instead,
directly call ufuncs:
 
>>> def add_mod5(x, y):
...     return np.add(x, y) % 5
...
>>> old_funcs = np.set_numeric_ops(add=add_mod5)
 
>>> x = np.arange(12).reshape((3, 4))
>>> x + x
array([[0, 2, 4, 1],
       [3, 0, 2, 4],
       [1, 3, 0, 2]])
 
>>> ignore = np.set_numeric_ops(**old_funcs) # restore operators
set_string_function(...)
set_string_function(f, repr=1)
 
Set a Python function to be used when pretty printing arrays.
 
Parameters
----------
f : Python function
    Function to be used to pretty print arrays. The function should expect
    a single array argument and return a string of the representation of
    the array.
repr : int
    Unknown.
 
Examples
--------
>>> def pprint(arr):
...     return 'HA! - What are you going to do now?'
...
>>> np.set_string_function(pprint)
>>> a = np.arange(10)
>>> a
HA! - What are you going to do now?
>>> print a
[0 1 2 3 4 5 6 7 8 9]
seterrobj(...)
seterrobj(errobj)
 
Used internally by `seterr`.
 
Parameters
----------
errobj : list
    [buffer_size, error_mask, callback_func]
 
See Also
--------
seterrcall
unpackbits(...)
unpackbits(myarray, axis=None)
 
Unpacks elements of a uint8 array into a binary-valued output array.
 
Each element of `myarray` represents a bit-field that should be unpacked
into a binary-valued output array. The shape of the output array is either
1-D (if `axis` is None) or the same shape as the input array with unpacking
done along the axis specified.
 
Parameters
----------
myarray : ndarrayuint8 type
   Input array.
axis : int, optional
   Unpacks along this axis.
 
Returns
-------
unpacked : ndarrayuint8 type
   The elements are binary-valued (0 or 1).
 
See Also
--------
packbits : Packs the elements of a binary-valued array into bits in a uint8
           array.
 
Examples
--------
>>> a = np.array([[2], [7], [23]], dtype=np.uint8)
>>> a
array([[ 2],
       [ 7],
       [23]], dtype=uint8)
>>> b = np.unpackbits(a, axis=1)
>>> b
array([[0, 0, 0, 0, 0, 0, 1, 0],
       [0, 0, 0, 0, 0, 1, 1, 1],
       [0, 0, 0, 1, 0, 1, 1, 1]], dtype=uint8)
vdot(...)
Return the dot product of two vectors.
 
The vdot(`a`, `b`) function handles complex numbers differently than
dot(`a`, `b`).  If the first argument is complex the complex conjugate
of the first argument is used for the calculation of the dot product.
 
For 2-D arrays it is equivalent to matrix multiplication, and for 1-D
arrays to inner product of vectors (with complex conjugation of `a`).
For N dimensions it is a sum product over the last axis of `a` and
the second-to-last of `b`::
 
    dot(a, b)[i,j,k,m] = sum(a[i,j,:] * b[k,:,m])
 
Parameters
----------
a : array_like
    If `a` is complex the complex conjugate is taken before calculation
    of the dot product.
b : array_like
    Second argument to the dot product.
 
Returns
-------
output : ndarray
    Returns dot product of `a` and `b`.  Can be an intfloat, or
    complex depending on the types of `a` and `b`.
 
See Also
--------
dot : Return the dot product without using the complex conjugate of the
      first argument.
 
Notes
-----
The dot product is the summation of element wise multiplication.
 
.. math::
 a \cdot b = \sum_{i=1}^n a_i^*b_i = a_1^*b_1+a_2^*b_2+\cdots+a_n^*b_n
 
Examples
--------
>>> a = np.array([1+2j,3+4j])
>>> b = np.array([5+6j,7+8j])
>>> np.vdot(a, b)
(70-8j)
>>> np.vdot(b, a)
(70+8j)
>>> a = np.array([[1, 4], [5, 6]])
>>> b = np.array([[4, 1], [2, 2]])
>>> np.vdot(a, b)
30
>>> np.vdot(b, a)
30
where(...)
where(condition, [x, y])
 
Return elements, either from `x` or `y`, depending on `condition`.
 
If only `condition` is given, return ``condition.nonzero()``.
 
Parameters
----------
condition : array_like, bool
    When True, yield `x`, otherwise yield `y`.
x, y : array_like, optional
    Values from which to choose.
 
Returns
-------
out : ndarray or tuple of ndarrays
    If both `x` and `y` are specified, the output array, shaped like
    `condition`, contains elements of `x` where `condition` is True,
    and elements from `y` elsewhere.
 
    If only `condition` is given, return the tuple
    ``condition.nonzero()``, the indices where `condition` is True.
 
See Also
--------
nonzero, choose
 
Notes
-----
If `x` and `y` are given and input arrays are 1-D, `where` is
equivalent to::
 
    [xv if c else yv for (c,xv,yv) in zip(condition,x,y)]
 
Examples
--------
>>> x = np.arange(9.).reshape(3, 3)
>>> np.where( x > 5 )
(array([2, 2, 2]), array([0, 1, 2]))
>>> x[np.where( x > 3.0 )]               # Note: result is 1D.
array([ 4.,  5.,  6.,  7.,  8.])
>>> np.where(x < 5, x, -1)               # Note: broadcasting.
array([[ 0.,  1.,  2.],
       [ 3.,  4., -1.],
       [-1., -1., -1.]])
 
>>> np.where([[True, False], [True, True]],
...          [[1, 2], [3, 4]],
...          [[9, 8], [7, 6]])
array([[1, 8],
       [3, 4]])
 
>>> np.where([[0, 1], [1, 0]])
(array([0, 1]), array([1, 0]))
zeros(...)
zeros(shape, dtype=float, order='C')
 
Return a new array of given shape and type, filled with zeros.
 
Parameters
----------
shape : {tuple of ints, int}
    Shape of the new array, e.g., ``(2, 3)`` or ``2``.
dtype : data-type, optional
    The desired data-type for the array, e.g., `numpy.int8`.  Default is
    `numpy.float64`.
order : {'C', 'F'}, optional
    Whether to store multidimensional data in C- or Fortran-contiguous
    (row- or column-wise) order in memory.
 
Returns
-------
out : ndarray
    Array of zeros with the given shape, dtype, and order.
 
See Also
--------
numpy.zeros_like : Return an array of zeros with shape and type of input.
numpy.ones_like : Return an array of ones with shape and type of input.
numpy.empty_like : Return an empty array with shape and type of input.
numpy.ones : Return a new array setting values to one.
numpy.empty : Return a new uninitialized array.
 
Examples
--------
>>> np.zeros(5)
array([ 0.,  0.,  0.,  0.,  0.])
 
>>> np.zeros((5,), dtype=numpy.int)
array([0, 0, 0, 0, 0])
 
>>> np.zeros((2, 1))
array([[ 0.],
       [ 0.]])
 
>>> s = (2,2)
>>> np.zeros(s)
array([[ 0.,  0.],
       [ 0.,  0.]])
 
>>> np.zeros((2,), dtype=[('x', 'i4'), ('y', 'i4')])
array([(0, 0), (0, 0)],
      dtype=[('x', '<i4'), ('y', '<i4')])

 
Data
        ALLOW_THREADS = 1
BUFSIZE = 10000
CLIP = 0
ERR_CALL = 3
ERR_DEFAULT = 0
ERR_DEFAULT2 = 2084
ERR_IGNORE = 0
ERR_LOG = 5
ERR_PRINT = 4
ERR_RAISE = 2
ERR_WARN = 1
FLOATING_POINT_SUPPORT = 1
FPE_DIVIDEBYZERO = 1
FPE_INVALID = 8
FPE_OVERFLOW = 2
FPE_UNDERFLOW = 4
False_ = False
Inf = inf
Infinity = inf
MAXDIMS = 32
NAN = nan
NINF = -inf
NZERO = -0.0
NaN = nan
PINF = inf
PZERO = 0.0
RAISE = 2
SHIFT_DIVIDEBYZERO = 0
SHIFT_INVALID = 9
SHIFT_OVERFLOW = 3
SHIFT_UNDERFLOW = 6
ScalarType = (<type 'int'>, <type 'float'>, <type 'complex'>, <type 'long'>, <type 'bool'>, <type 'str'>, <type 'unicode'>, <type 'buffer'>, <type 'numpy.int64'>, <type 'numpy.int16'>, <type 'numpy.float128'>, <type 'numpy.string_'>, <type 'numpy.int8'>, <type 'numpy.uint8'>, <type 'numpy.float32'>, <type 'numpy.complex256'>, <type 'numpy.int32'>, <type 'numpy.int64'>, <type 'numpy.uint64'>, <type 'numpy.complex64'>, ...)
True_ = True
UFUNC_BUFSIZE_DEFAULT = 10000
UFUNC_PYVALS_NAME = 'UFUNC_PYVALS'
WRAP = 1
__NUMPY_SETUP__ = False
__all__ = ['add_newdocs', '__version__', 'pkgload', 'PackageLoader', 'show_config', 'char', 'rec', 'memmap', 'newaxis', 'ndarray', 'flatiter', 'ufunc', 'arange', 'array', 'zeros', 'empty', 'broadcast', 'dtype', 'fromstring', 'fromfile', ...]
__file__ = '/usr/lib/python2.6/dist-packages/numpy/__init__.pyc'
__name__ = 'numpy'
__package__ = 'numpy'
__path__ = ['/usr/lib/python2.6/dist-packages/numpy']
__version__ = '1.3.0'
abs = <ufunc 'absolute'>
absolute = <ufunc 'absolute'>
add = <ufunc 'add'>
arccos = <ufunc 'arccos'>
arccosh = <ufunc 'arccosh'>
arcsin = <ufunc 'arcsin'>
arcsinh = <ufunc 'arcsinh'>
arctan = <ufunc 'arctan'>
arctan2 = <ufunc 'arctan2'>
arctanh = <ufunc 'arctanh'>
bitwise_and = <ufunc 'bitwise_and'>
bitwise_not = <ufunc 'invert'>
bitwise_or = <ufunc 'bitwise_or'>
bitwise_xor = <ufunc 'bitwise_xor'>
c_ = <numpy.lib.index_tricks.CClass object at 0x23581d0>
cast = {<type 'numpy.int64'>: <function <lambda> at 0x2... 'numpy.void'>: <function <lambda> at 0x22368c0>}
ceil = <ufunc 'ceil'>
conj = <ufunc 'conjugate'>
conjugate = <ufunc 'conjugate'>
cos = <ufunc 'cos'>
cosh = <ufunc 'cosh'>
deg2rad = <ufunc 'deg2rad'>
degrees = <ufunc 'degrees'>
divide = <ufunc 'divide'>
e = 2.7182818284590451
equal = <ufunc 'equal'>
exp = <ufunc 'exp'>
exp2 = <ufunc 'exp2'>
expm1 = <ufunc 'expm1'>
fabs = <ufunc 'fabs'>
floor = <ufunc 'floor'>
floor_divide = <ufunc 'floor_divide'>
fmax = <ufunc 'fmax'>
fmin = <ufunc 'fmin'>
fmod = <ufunc 'fmod'>
frexp = <ufunc 'frexp'>
greater = <ufunc 'greater'>
greater_equal = <ufunc 'greater_equal'>
hypot = <ufunc 'hypot'>
index_exp = <numpy.lib.index_tricks.IndexExpression object at 0x2358290>
inf = inf
infty = inf
invert = <ufunc 'invert'>
isfinite = <ufunc 'isfinite'>
isinf = <ufunc 'isinf'>
isnan = <ufunc 'isnan'>
ldexp = <ufunc 'ldexp'>
left_shift = <ufunc 'left_shift'>
less = <ufunc 'less'>
less_equal = <ufunc 'less_equal'>
little_endian = True
log = <ufunc 'log'>
log10 = <ufunc 'log10'>
log1p = <ufunc 'log1p'>
logaddexp = <ufunc 'logaddexp'>
logaddexp2 = <ufunc 'logaddexp2'>
logical_and = <ufunc 'logical_and'>
logical_not = <ufunc 'logical_not'>
logical_or = <ufunc 'logical_or'>
logical_xor = <ufunc 'logical_xor'>
maximum = <ufunc 'maximum'>
mgrid = <numpy.lib.index_tricks.nd_grid object at 0x21d1dd0>
minimum = <ufunc 'minimum'>
mod = <ufunc 'remainder'>
modf = <ufunc 'modf'>
multiply = <ufunc 'multiply'>
nan = nan
nbytes = {<type 'numpy.int64'>: 8, <type 'numpy.int16'>: ... 'numpy.complex128'>: 16, <type 'numpy.void'>: 0}
negative = <ufunc 'negative'>
newaxis = None
not_equal = <ufunc 'not_equal'>
ogrid = <numpy.lib.index_tricks.nd_grid object at 0x2358050>
ones_like = <ufunc 'ones_like'>
pi = 3.1415926535897931
power = <ufunc 'power'>
r_ = <numpy.lib.index_tricks.RClass object at 0x2358110>
rad2deg = <ufunc 'rad2deg'>
radians = <ufunc 'radians'>
reciprocal = <ufunc 'reciprocal'>
remainder = <ufunc 'remainder'>
right_shift = <ufunc 'right_shift'>
rint = <ufunc 'rint'>
s_ = <numpy.lib.index_tricks.IndexExpression object at 0x2358310>
sctypeDict = {0: <type 'numpy.bool_'>, 1: <type 'numpy.int8'>, 2: <type 'numpy.uint8'>, 3: <type 'numpy.int16'>, 4: <type 'numpy.uint16'>, 5: <type 'numpy.int32'>, 6: <type 'numpy.uint32'>, 7: <type 'numpy.int64'>, 8: <type 'numpy.uint64'>, 9: <type 'numpy.int64'>, ...}
sctypeNA = {'?': 'Bool', 'B': 'UInt8', 'Bool': <type 'numpy.bool_'>, 'Complex128': <type 'numpy.complex256'>, 'Complex32': <type 'numpy.complex64'>, 'Complex64': <type 'numpy.complex128'>, 'D': 'Complex64', 'F': 'Complex32', 'Float128': <type 'numpy.float128'>, 'Float32': <type 'numpy.float32'>, ...}
sctypes = {'complex': [<type 'numpy.complex64'>, <type 'numpy.complex128'>, <type 'numpy.complex256'>], 'float': [<type 'numpy.float32'>, <type 'numpy.float64'>, <type 'numpy.float128'>], 'int': [<type 'numpy.int8'>, <type 'numpy.int16'>, <type 'numpy.int32'>, <type 'numpy.int64'>], 'others': [<type 'bool'>, <type 'object'>, <type 'str'>, <type 'unicode'>, <type 'numpy.void'>], 'uint': [<type 'numpy.uint8'>, <type 'numpy.uint16'>, <type 'numpy.uint32'>, <type 'numpy.uint64'>]}
sign = <ufunc 'sign'>
signbit = <ufunc 'signbit'>
sin = <ufunc 'sin'>
sinh = <ufunc 'sinh'>
sqrt = <ufunc 'sqrt'>
square = <ufunc 'square'>
subtract = <ufunc 'subtract'>
tan = <ufunc 'tan'>
tanh = <ufunc 'tanh'>
true_divide = <ufunc 'true_divide'>
trunc = <ufunc 'trunc'>
typeDict = {0: <type 'numpy.bool_'>, 1: <type 'numpy.int8'>, 2: <type 'numpy.uint8'>, 3: <type 'numpy.int16'>, 4: <type 'numpy.uint16'>, 5: <type 'numpy.int32'>, 6: <type 'numpy.uint32'>, 7: <type 'numpy.int64'>, 8: <type 'numpy.uint64'>, 9: <type 'numpy.int64'>, ...}
typeNA = {'?': 'Bool', 'B': 'UInt8', 'Bool': <type 'numpy.bool_'>, 'Complex128': <type 'numpy.complex256'>, 'Complex32': <type 'numpy.complex64'>, 'Complex64': <type 'numpy.complex128'>, 'D': 'Complex64', 'F': 'Complex32', 'Float128': <type 'numpy.float128'>, 'Float32': <type 'numpy.float32'>, ...}
typecodes = {'All': '?bhilqpBHILQPfdgFDGSUVO', 'AllFloat': 'fdgFDG', 'AllInteger': 'bBhHiIlLqQpP', 'Character': 'c', 'Complex': 'FDG', 'Float': 'fdg', 'Integer': 'bhilqp', 'UnsignedInteger': 'BHILQP'}