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&nbs