numpy (version 1.8.0rc1)
index
/System/Library/Frameworks/Python.framework/Versions/2.7/Extras/lib/python/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 = 42
  >>> x = x + 1
 
Use the built-in ``help`` function to view a function's docstring::
 
  >>> help(np.sort)
  ... # doctest: +SKIP
 
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')
  ... # doctest: +SKIP
 
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)
  ... # doctest: +SKIP
 
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
polynomial
    Polynomial tools
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., `np.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__
_import_tools
add_newdocs
compat (package)
core (package)
ctypeslib
distutils (package)
doc (package)
dual
f2py (package)
fft (package)
lib (package)
linalg (package)
ma (package)
matlib
matrixlib (package)
numarray (package)
oldnumeric (package)
polynomial (package)
random (package)
setup
testing (package)
version

 
Classes
       
__builtin__.object
broadcast
busdaycalendar
dtype
flatiter
generic
bool_
datetime64
flexible
character
string_(__builtin__.str, character)
unicode_(__builtin__.unicode, character)
void
numpy.core.records.record
number
inexact
complexfloating
complex128(complexfloating, __builtin__.complex)
complex256
complex64
floating
float128
float16
float32
float64(floating, __builtin__.float)
integer
signedinteger
int16
int32
int64(signedinteger, __builtin__.int)
int64(signedinteger, __builtin__.int)
int8
timedelta64
unsignedinteger
uint16
uint32
uint64
uint64
uint8
object_
ndarray
numpy.core.defchararray.chararray
numpy.core.memmap.memmap
numpy.core.records.recarray
numpy.matrixlib.defmatrix.matrix
nditer
ufunc
numpy._import_tools.PackageLoader
numpy.core.getlimits.finfo
numpy.core.getlimits.iinfo
numpy.core.machar.MachAr
numpy.core.numeric.errstate
numpy.lib._datasource.DataSource
numpy.lib.function_base.vectorize
numpy.lib.index_tricks.ndenumerate
numpy.lib.index_tricks.ndindex
numpy.lib.polynomial.poly1d
__builtin__.str(__builtin__.basestring)
string_(__builtin__.str, character)
__builtin__.unicode(__builtin__.basestring)
unicode_(__builtin__.unicode, character)
exceptions.DeprecationWarning(exceptions.Warning)
ModuleDeprecationWarning
exceptions.RuntimeWarning(exceptions.Warning)
numpy.core.numeric.ComplexWarning
numpy.lib.nanfunctions.NanWarning
exceptions.UserWarning(exceptions.Warning)
numpy.lib.polynomial.RankWarning
numpy.core.records.format_parser

 
class ComplexWarning(exceptions.RuntimeWarning)
    The warning raised when casting a complex dtype to a real dtype.
 
As implemented, casting a complex number to a real discards its imaginary
part, but this behavior may not be what the user actually wants.
 
 
Method resolution order:
ComplexWarning
exceptions.RuntimeWarning
exceptions.Warning
exceptions.Exception
exceptions.BaseException
__builtin__.object

Data descriptors defined here:
__weakref__
list of weak references to the object (if defined)

Methods inherited from exceptions.RuntimeWarning:
__init__(...)
x.__init__(...) initializes x; see help(type(x)) for signature

Data and other attributes inherited from exceptions.RuntimeWarning:
__new__ = <built-in method __new__ of type object>
T.__new__(S, ...) -> a new object with type S, a subtype of T

Methods inherited from exceptions.BaseException:
__delattr__(...)
x.__delattr__('name') <==> del x.name
__getattribute__(...)
x.__getattribute__('name') <==> x.name
__getitem__(...)
x.__getitem__(y) <==> x[y]
__getslice__(...)
x.__getslice__(i, j) <==> x[i:j]
 
Use of negative indices is not supported.
__reduce__(...)
__repr__(...)
x.__repr__() <==> repr(x)
__setattr__(...)
x.__setattr__('name', value) <==> x.name = value
__setstate__(...)
__str__(...)
x.__str__() <==> str(x)
__unicode__(...)

Data descriptors inherited from exceptions.BaseException:
__dict__
args
message

 
class DataSource(__builtin__.object)
    DataSource(destpath='.')
 
generic data source file (file, http, ftp, ...).
 
DataSources can be local files or remote files/URLs.  The files may
also be compressed or uncompressed. DataSource hides some of the low-level
details of downloading the file, allowing you to simply pass in a valid
file path (or URL) and obtain a file object.
 
Parameters
----------
destpath : str or None, optional
    Path to the directory where the source file gets downloaded to for use.
    If `destpath` is None, a temporary directory will be created.
    The default path is the current directory.
 
Notes
-----
URLs require a scheme string (``http://``) to be used, without it they
will fail::
 
    >>> repos = DataSource()
    >>> repos.exists('www.google.com/index.html')
    False
    >>> repos.exists('http://www.google.com/index.html')
    True
 
Temporary directories are deleted when the DataSource is deleted.
 
Examples
--------
::
 
    >>> ds = DataSource('/home/guido')
    >>> urlname = 'http://www.google.com/index.html'
    >>> gfile = ds.open('http://www.google.com/index.html')  # remote file
    >>> ds.abspath(urlname)
    '/home/guido/www.google.com/site/index.html'
 
    >>> ds = DataSource(None)  # use with temporary file
    >>> ds.open('/home/guido/foobar.txt')
    <open file '/home/guido.foobar.txt', mode 'r' at 0x91d4430>
    >>> ds.abspath('/home/guido/foobar.txt')
    '/tmp/tmpy4pgsP/home/guido/foobar.txt'
 
  Methods defined here:
__del__(self)
__init__(self, destpath='.')
Create a DataSource with a local path at destpath.
abspath(self, path)
Return absolute path of file in the DataSource directory.
 
If `path` is an URL, then `abspath` will return either the location
the file exists locally or the location it would exist when opened
using the `open` method.
 
Parameters
----------
path : str
    Can be a local file or a remote URL.
 
Returns
-------
out : str
    Complete path, including the `DataSource` destination directory.
 
Notes
-----
The functionality is based on `os.path.abspath`.
exists(self, path)
Test if path exists.
 
Test if `path` exists as (and in this order):
 
- a local file.
- a remote URL that has been downloaded and stored locally in the
  `DataSource` directory.
- a remote URL that has not been downloaded, but is valid and accessible.
 
Parameters
----------
path : str
    Can be a local file or a remote URL.
 
Returns
-------
out : bool
    True if `path` exists.
 
Notes
-----
When `path` is an URL, `exists` will return True if it's either stored
locally in the `DataSource` directory, or is a valid remote URL.
`DataSource` does not discriminate between the two, the file is accessible
if it exists in either location.
open(self, path, mode='r')
Open and return file-like object.
 
If `path` is an URL, it will be downloaded, stored in the `DataSource`
directory and opened from there.
 
Parameters
----------
path : str
    Local file path or URL to open.
mode : {'r', 'w', 'a'}, optional
    Mode to open `path`.  Mode 'r' for reading, 'w' for writing, 'a' to
    append. Available modes depend on the type of object specified by
    `path`. Default is 'r'.
 
Returns
-------
out : file object
    File object.

Data descriptors defined here:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
class MachAr(__builtin__.object)
    Diagnosing machine parameters.
 
Attributes
----------
ibeta : int
    Radix in which numbers are represented.
it : int
    Number of base-`ibeta` digits in the floating point mantissa M.
machep : int
    Exponent of the smallest (most negative) power of `ibeta` that,
    added to 1.0, gives something different from 1.0
eps : float
    Floating-point number ``beta**machep`` (floating point precision)
negep : int
    Exponent of the smallest power of `ibeta` that, substracted
    from 1.0, gives something different from 1.0.
epsneg : float
    Floating-point number ``beta**negep``.
iexp : int
    Number of bits in the exponent (including its sign and bias).
minexp : int
    Smallest (most negative) power of `ibeta` consistent with there
    being no leading zeros in the mantissa.
xmin : float
    Floating point number ``beta**minexp`` (the smallest [in
    magnitude] usable floating value).
maxexp : int
    Smallest (positive) power of `ibeta` that causes overflow.
xmax : float
    ``(1-epsneg) * beta**maxexp`` (the largest [in magnitude]
    usable floating value).
irnd : int
    In ``range(6)``, information on what kind of rounding is done
    in addition, and on how underflow is handled.
ngrd : int
    Number of 'guard digits' used when truncating the product
    of two mantissas to fit the representation.
epsilon : float
    Same as `eps`.
tiny : float
    Same as `xmin`.
huge : float
    Same as `xmax`.
precision : float
    ``- int(-log10(eps))``
resolution : float
    ``- 10**(-precision)``
 
Parameters
----------
float_conv : function, optional
    Function that converts an integer or integer array to a float
    or float array. Default is `float`.
int_conv : function, optional
    Function that converts a float or float array to an integer or
    integer array. Default is `int`.
float_to_float : function, optional
    Function that converts a float array to float. Default is `float`.
    Note that this does not seem to do anything useful in the current
    implementation.
float_to_str : function, optional
    Function that converts a single float to a string. Default is
    ``lambda v:'%24.16e' %v``.
title : str, optional
    Title that is printed in the string representation of `MachAr`.
 
See Also
--------
finfo : Machine limits for floating point types.
iinfo : Machine limits for integer types.
 
References
----------
.. [1] Press, Teukolsky, Vetterling and Flannery,
       "Numerical Recipes in C++," 2nd ed,
       Cambridge University Press, 2002, p. 31.
 
  Methods defined here:
__init__(self, float_conv=<type 'float'>, int_conv=<type 'int'>, float_to_float=<type 'float'>, float_to_str=<function <lambda>>, title='Python floating point number')
float_conv - convert integer to float (array)
int_conv   - convert float (array) to integer
float_to_float - convert float array to float
float_to_str - convert array float to str
title        - description of used floating point numbers
__str__(self)

Data descriptors defined here:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
class ModuleDeprecationWarning(exceptions.DeprecationWarning)
    Module deprecation warning.
 
The nose tester turns ordinary Deprecation warnings into test failures.
That makes it hard to deprecate whole modules, because they get
imported by default. So this is a special Deprecation warning that the
nose tester will let pass without making tests fail.
 
 
Method resolution order:
ModuleDeprecationWarning
exceptions.DeprecationWarning
exceptions.Warning
exceptions.Exception
exceptions.BaseException
__builtin__.object

Data descriptors defined here:
__weakref__
list of weak references to the object (if defined)

Methods inherited from exceptions.DeprecationWarning:
__init__(...)
x.__init__(...) initializes x; see help(type(x)) for signature

Data and other attributes inherited from exceptions.DeprecationWarning:
__new__ = <built-in method __new__ of type object>
T.__new__(S, ...) -> a new object with type S, a subtype of T

Methods inherited from exceptions.BaseException:
__delattr__(...)
x.__delattr__('name') <==> del x.name
__getattribute__(...)
x.__getattribute__('name') <==> x.name
__getitem__(...)
x.__getitem__(y) <==> x[y]
__getslice__(...)
x.__getslice__(i, j) <==> x[i:j]
 
Use of negative indices is not supported.
__reduce__(...)
__repr__(...)
x.__repr__() <==> repr(x)
__setattr__(...)
x.__setattr__('name', value) <==> x.name = value
__setstate__(...)
__str__(...)
x.__str__() <==> str(x)
__unicode__(...)

Data descriptors inherited from exceptions.BaseException:
__dict__
args
message

 
class NanWarning(exceptions.RuntimeWarning)
    
Method resolution order:
NanWarning
exceptions.RuntimeWarning
exceptions.Warning
exceptions.Exception
exceptions.BaseException
__builtin__.object

Data descriptors defined here:
__weakref__
list of weak references to the object (if defined)

Methods inherited from exceptions.RuntimeWarning:
__init__(...)
x.__init__(...) initializes x; see help(type(x)) for signature

Data and other attributes inherited from exceptions.RuntimeWarning:
__new__ = <built-in method __new__ of type object>
T.__new__(S, ...) -> a new object with type S, a subtype of T

Methods inherited from exceptions.BaseException:
__delattr__(...)
x.__delattr__('name') <==> del x.name
__getattribute__(...)
x.__getattribute__('name') <==> x.name
__getitem__(...)
x.__getitem__(y) <==> x[y]
__getslice__(...)
x.__getslice__(i, j) <==> x[i:j]
 
Use of negative indices is not supported.
__reduce__(...)
__repr__(...)
x.__repr__() <==> repr(x)
__setattr__(...)
x.__setattr__('name', value) <==> x.name = value
__setstate__(...)
__str__(...)
x.__str__() <==> str(x)
__unicode__(...)

Data descriptors inherited from exceptions.BaseException:
__dict__
args
message

 
class PackageLoader(__builtin__.object)
     Methods defined here:
__call__(self, *packages, **options)
Load one or more packages into parent package top-level namespace.
 
This function is intended to shorten the need to import many
subpackages, say of scipy, constantly with statements such as
 
  import scipy.linalg, scipy.fftpack, scipy.etc...
 
Instead, you can say:
 
  import scipy
  scipy.pkgload('linalg','fftpack',...)
 
or
 
  scipy.pkgload()
 
to load all of them in one call.
 
If a name which doesn't exist in scipy's namespace is
given, a warning is shown.
 
Parameters
----------
 *packages : arg-tuple
      the names (one or more strings) of all the modules one
      wishes to load into the top-level namespace.
 verbose= : integer
      verbosity level [default: -1].
      verbose=-1 will suspend also warnings.
 force= : bool
      when True, force reloading loaded packages [default: False].
 postpone= : bool
      when True, don't load packages [default: False]
__init__(self, verbose=False, infunc=False)
Manages loading packages.
error(self, mess)
get_pkgdocs(self)
Return documentation summary of subpackages.
log(self, mess)
warn(self, mess)

Data descriptors defined here:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
class RankWarning(exceptions.UserWarning)
    Issued by `polyfit` when the Vandermonde matrix is rank deficient.
 
For more information, a way to suppress the warning, and an example of
`RankWarning` being issued, see `polyfit`.
 
 
Method resolution order:
RankWarning
exceptions.UserWarning
exceptions.Warning
exceptions.Exception
exceptions.BaseException
__builtin__.object

Data descriptors defined here:
__weakref__
list of weak references to the object (if defined)

Methods inherited from exceptions.UserWarning:
__init__(...)
x.__init__(...) initializes x; see help(type(x)) for signature

Data and other attributes inherited from exceptions.UserWarning:
__new__ = <built-in method __new__ of type object>
T.__new__(S, ...) -> a new object with type S, a subtype of T

Methods inherited from exceptions.BaseException:
__delattr__(...)
x.__delattr__('name') <==> del x.name
__getattribute__(...)
x.__getattribute__('name') <==> x.name
__getitem__(...)
x.__getitem__(y) <==> x[y]
__getslice__(...)
x.__getslice__(i, j) <==> x[i:j]
 
Use of negative indices is not supported.
__reduce__(...)
__repr__(...)
x.__repr__() <==> repr(x)
__setattr__(...)
x.__setattr__('name', value) <==> x.name = value
__setstate__(...)
__str__(...)
x.__str__() <==> str(x)
__unicode__(...)

Data descriptors inherited from exceptions.BaseException:
__dict__
args
message

 
bool8 = class bool_(generic)
    Numpy's Boolean type.  Character code: ``?``.  Alias: bool8
 
 
Method resolution order:
bool_
generic
__builtin__.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>
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
__format__(...)
NumPy array scalar formatter
__getitem__(...)
x.__getitem__(y) <==> x[y]
__hex__(...)
x.__hex__() <==> hex(x)
__int__(...)
x.__int__() <==> int(x)
__invert__(...)
x.__invert__() <==> ~x
__long__(...)
x.__long__() <==> long(x)
__lshift__(...)
x.__lshift__(y) <==> x<<y
__mod__(...)
x.__mod__(y) <==> x%y
__mul__(...)
x.__mul__(y) <==> x*y
__neg__(...)
x.__neg__() <==> -x
__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(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
any(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
argmax(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
argmin(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
argsort(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
astype(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
byteswap(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class so as to
provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
choose(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
clip(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
compress(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
conj(...)
conjugate(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
copy(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
cumprod(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
cumsum(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
diagonal(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
dump(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
dumps(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
fill(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
flatten(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
getfield(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
item(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
itemset(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
max(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
mean(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
min(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
newbyteorder(...)
newbyteorder(new_order='S')
 
Return a new `dtype` with a different byte order.
 
Changes are also made in all fields and sub-arrays of the data type.
 
The `new_order` code can be any from the following:
 
* {'<', '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 : str, optional
    Byte order to force; a value from the byte order specifications
    above.  The default value ('S') results in swapping the current
    byte order. The code does a case-insensitive check on the first
    letter of `new_order` for the alternatives above.  For example,
    any of 'B' or 'b' or 'biggish' are valid to specify big-endian.
 
 
Returns
-------
new_dtype : dtype
    New `dtypeobject with the given change to the byte order.
nonzero(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
prod(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
ptp(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
put(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
ravel(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
repeat(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
reshape(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
resize(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
round(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
searchsorted(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
setfield(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
setflags(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class so as to
provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
sort(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
squeeze(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
std(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
sum(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
swapaxes(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
take(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
tofile(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
tolist(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
tostring(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
trace(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
transpose(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
var(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
view(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.

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

 
class bool_(generic)
    Numpy's Boolean type.  Character code: ``?``.  Alias: bool8
 
 
Method resolution order:
bool_
generic
__builtin__.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>
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
__format__(...)
NumPy array scalar formatter
__getitem__(...)
x.__getitem__(y) <==> x[y]
__hex__(...)
x.__hex__() <==> hex(x)
__int__(...)
x.__int__() <==> int(x)
__invert__(...)
x.__invert__() <==> ~x
__long__(...)
x.__long__() <==> long(x)
__lshift__(...)
x.__lshift__(y) <==> x<<y
__mod__(...)
x.__mod__(y) <==> x%y
__mul__(...)
x.__mul__(y) <==> x*y
__neg__(...)
x.__neg__() <==> -x
__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(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
any(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
argmax(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
argmin(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
argsort(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
astype(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
byteswap(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class so as to
provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
choose(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
clip(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
compress(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
conj(...)
conjugate(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
copy(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
cumprod(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
cumsum(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
diagonal(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
dump(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
dumps(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
fill(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
flatten(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
getfield(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
item(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
itemset(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
max(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
mean(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
min(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
newbyteorder(...)
newbyteorder(new_order='S')
 
Return a new `dtype` with a different byte order.
 
Changes are also made in all fields and sub-arrays of the data type.
 
The `new_order` code can be any from the following:
 
* {'<', '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 : str, optional
    Byte order to force; a value from the byte order specifications
    above.  The default value ('S') results in swapping the current
    byte order. The code does a case-insensitive check on the first
    letter of `new_order` for the alternatives above.  For example,
    any of 'B' or 'b' or 'biggish' are valid to specify big-endian.
 
 
Returns
-------
new_dtype : dtype
    New `dtypeobject with the given change to the byte order.
nonzero(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
prod(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
ptp(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
put(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
ravel(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
repeat(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
reshape(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
resize(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
round(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
searchsorted(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
setfield(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
setflags(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class so as to
provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
sort(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
squeeze(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
std(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
sum(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
swapaxes(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
take(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
tofile(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
tolist(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
tostring(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
trace(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
transpose(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
var(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
view(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.

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

 
class broadcast(__builtin__.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(...)
reset()
 
Reset the broadcasted result's iterator(s).
 
Parameters
----------
None
 
Returns
-------
None
 
Examples
--------
>>> x = np.array([1, 2, 3])
>>> y = np.array([[4], [5], [6]]
>>> b = np.broadcast(x, y)
>>> b.index
0
>>> b.next(), b.next(), b.next()
((1, 4), (2, 4), (3, 4))
>>> b.index
3
>>> b.reset()
>>> b.index
0

Data descriptors defined here:
index
current index in broadcasted result
 
Examples
--------
>>> x = np.array([[1], [2], [3]])
>>> y = np.array([4, 5, 6])
>>> b = np.broadcast(x, y)
>>> b.index
0
>>> b.next(), b.next(), b.next()
((1, 4), (1, 5), (1, 6))
>>> b.index
3
iters
tuple of iterators along ``self``'s "components."
 
Returns a tuple of `numpy.flatiter` objects, one for each "component"
of ``self``.
 
See Also
--------
numpy.flatiter
 
Examples
--------
>>> x = np.array([1, 2, 3])
>>> y = np.array([[4], [5], [6]])
>>> b = np.broadcast(x, y)
>>> row, col = b.iters
>>> row.next(), col.next()
(1, 4)
nd
Number of dimensions of broadcasted result.
 
Examples
--------
>>> x = np.array([1, 2, 3])
>>> y = np.array([[4], [5], [6]])
>>> b = np.broadcast(x, y)
>>> b.nd
2
numiter
Number of iterators possessed by the broadcasted result.
 
Examples
--------
>>> x = np.array([1, 2, 3])
>>> y = np.array([[4], [5], [6]])
>>> b = np.broadcast(x, y)
>>> b.numiter
2
shape
Shape of broadcasted result.
 
Examples
--------
>>> x = np.array([1, 2, 3])
>>> y = np.array([[4], [5], [6]])
>>> b = np.broadcast(x, y)
>>> b.shape
(3, 3)
size
Total size of broadcasted result.
 
Examples
--------
>>> x = np.array([1, 2, 3])
>>> y = np.array([[4], [5], [6]])
>>> b = np.broadcast(x, y)
>>> b.size
9

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

 
class busdaycalendar(__builtin__.object)
    busdaycalendar(weekmask='1111100', holidays=None)
 
A business day calendar object that efficiently stores information
defining valid days for the busday family of functions.
 
The default valid days are Monday through Friday ("business days").
busdaycalendar object can be specified with any set of weekly
valid days, plus an optional "holiday" dates that always will be invalid.
 
Once a busdaycalendar object is created, the weekmask and holidays
cannot be modified.
 
.. versionadded:: 1.7.0
 
Parameters
----------
weekmask : str or array_like of bool, optional
    A seven-element array indicating which of Monday through Sunday are
    valid days. May be specified as a length-seven list or array, like
    [1,1,1,1,1,0,0]; a length-seven string, like '1111100'; or a string
    like "Mon Tue Wed Thu Fri", made up of 3-character abbreviations for
    weekdays, optionally separated by white space. Valid abbreviations
    are: Mon Tue Wed Thu Fri Sat Sun
holidays : array_like of datetime64[D], optional
    An array of dates to consider as invalid dates, no matter which
    weekday they fall upon.  Holiday dates may be specified in any
    order, and NaT (not-a-time) dates are ignored.  This list is
    saved in a normalized form that is suited for fast calculations
    of valid days.
 
Returns
-------
out : busdaycalendar
    A business day calendar object containing the specified
    weekmask and holidays values.
 
See Also
--------
is_busday : Returns a boolean array indicating valid days.
busday_offset : Applies an offset counted in valid days.
busday_count : Counts how many valid days are in a half-open date range.
 
Attributes
----------
Note: once a busdaycalendar object is created, you cannot modify the
weekmask or holidays.  The attributes return copies of internal data.
weekmask : (copy) seven-element array of bool
holidays : (copy) sorted array of datetime64[D]
 
Examples
--------
>>> # Some important days in July
... bdd = np.busdaycalendar(
...             holidays=['2011-07-01', '2011-07-04', '2011-07-17'])
>>> # Default is Monday to Friday weekdays
... bdd.weekmask
array([ True,  True,  True,  True,  True, False, False], dtype='bool')
>>> # Any holidays already on the weekend are removed
... bdd.holidays
array(['2011-07-01', '2011-07-04'], dtype='datetime64[D]')
 
  Methods defined here:
__init__(...)
x.__init__(...) initializes x; see help(type(x)) for signature

Data descriptors defined here:
holidays
A copy of the holiday array indicating additional invalid days.
weekmask
A copy of the seven-element boolean mask indicating valid days.

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

 
byte = class int8(signedinteger)
    8-bit integer. Character code ``b``. C char compatible.
 
 
Method resolution order:
int8
signedinteger
integer
number
generic
__builtin__.object

Methods defined here:
__eq__(...)
x.__eq__(y) <==> x==y
__ge__(...)
x.__ge__(y) <==> x>=y
__gt__(...)
x.__gt__(y) <==> x>y
__hash__(...)
x.__hash__() <==> hash(x)
__index__(...)
x[y:z] <==> x[y.__index__():z.__index__()]
__le__(...)
x.__le__(y) <==> x<=y
__lt__(...)
x.__lt__(y) <==> x<y
__ne__(...)
x.__ne__(y) <==> x!=y

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

Methods inherited from generic:
__abs__(...)
x.__abs__() <==> abs(x)
__add__(...)
x.__add__(y) <==> x+y
__and__(...)
x.__and__(y) <==> x&y
__array__(...)
sc.__array__(|type) return 0-dim array
__array_wrap__(...)
sc.__array_wrap__(obj) return scalar from array
__copy__(...)
__deepcopy__(...)
__div__(...)
x.__div__(y) <==> x/y
__divmod__(...)
x.__divmod__(y) <==> divmod(x, y)
__float__(...)
x.__float__() <==> float(x)
__floordiv__(...)
x.__floordiv__(y) <==> x//y
__format__(...)
NumPy array scalar formatter
__getitem__(...)
x.__getitem__(y) <==> x[y]
__hex__(...)
x.__hex__() <==> hex(x)
__int__(...)
x.__int__() <==> int(x)
__invert__(...)
x.__invert__() <==> ~x
__long__(...)
x.__long__() <==> long(x)
__lshift__(...)
x.__lshift__(y) <==> x<<y
__mod__(...)
x.__mod__(y) <==> x%y
__mul__(...)
x.__mul__(y) <==> x*y
__neg__(...)
x.__neg__() <==> -x
__nonzero__(...)
x.__nonzero__() <==> x != 0
__oct__(...)
x.__oct__() <==> oct(x)
__or__(...)
x.__or__(y) <==> x|y
__pos__(...)
x.__pos__() <==> +x
__pow__(...)
x.__pow__(y[, z]) <==> pow(x, y[, z])
__radd__(...)
x.__radd__(y) <==> y+x
__rand__(...)
x.__rand__(y) <==> y&x
__rdiv__(...)
x.__rdiv__(y) <==> y/x
__rdivmod__(...)
x.__rdivmod__(y) <==> divmod(y, x)
__reduce__(...)
__repr__(...)
x.__repr__() <==> repr(x)
__rfloordiv__(...)
x.__rfloordiv__(y) <==> y//x
__rlshift__(...)
x.__rlshift__(y) <==> y<<x
__rmod__(...)
x.__rmod__(y) <==> y%x
__rmul__(...)
x.__rmul__(y) <==> y*x
__ror__(...)
x.__ror__(y) <==> y|x
__rpow__(...)
y.__rpow__(x[, z]) <==> pow(x, y[, z])
__rrshift__(...)
x.__rrshift__(y) <==> y>>x
__rshift__(...)
x.__rshift__(y) <==> x>>y
__rsub__(...)
x.__rsub__(y) <==> y-x
__rtruediv__(...)
x.__rtruediv__(y) <==> y/x
__rxor__(...)
x.__rxor__(y) <==> y^x
__setstate__(...)
__str__(...)
x.__str__() <==> str(x)
__sub__(...)
x.__sub__(y) <==> x-y
__truediv__(...)
x.__truediv__(y) <==> x/y
__xor__(...)
x.__xor__(y) <==> x^y
all(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
any(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
argmax(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
argmin(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
argsort(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
astype(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
byteswap(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class so as to
provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
choose(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
clip(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
compress(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
conj(...)
conjugate(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
copy(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
cumprod(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
cumsum(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
diagonal(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
dump(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
dumps(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
fill(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
flatten(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
getfield(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
item(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
itemset(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
max(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
mean(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
min(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
newbyteorder(...)
newbyteorder(new_order='S')
 
Return a new `dtype` with a different byte order.
 
Changes are also made in all fields and sub-arrays of the data type.
 
The `new_order` code can be any from the following:
 
* {'<', '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 : str, optional
    Byte order to force; a value from the byte order specifications
    above.  The default value ('S') results in swapping the current
    byte order. The code does a case-insensitive check on the first
    letter of `new_order` for the alternatives above.  For example,
    any of 'B' or 'b' or 'biggish' are valid to specify big-endian.
 
 
Returns
-------
new_dtype : dtype
    New `dtypeobject with the given change to the byte order.
nonzero(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
prod(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
ptp(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
put(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
ravel(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
repeat(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
reshape(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
resize(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
round(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
searchsorted(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
setfield(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
setflags(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class so as to
provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
sort(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
squeeze(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
std(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
sum(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
swapaxes(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
take(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
tofile(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
tolist(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
tostring(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
trace(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
transpose(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
var(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
view(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.

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

 
bytes_ = class string_(__builtin__.str, character)
    
Method resolution order:
string_
__builtin__.str
__builtin__.basestring
character
flexible
generic
__builtin__.object

Methods defined here:
__eq__(...)
x.__eq__(y) <==> x==y
__ge__(...)
x.__ge__(y) <==> x>=y
__gt__(...)
x.__gt__(y) <==> x>y
__hash__(...)
x.__hash__() <==> hash(x)
__le__(...)
x.__le__(y) <==> x<=y
__lt__(...)
x.__lt__(y) <==> x<y
__ne__(...)
x.__ne__(y) <==> x!=y
__repr__(...)
x.__repr__() <==> repr(x)
__str__(...)
x.__str__() <==> str(x)

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

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

Methods inherited from generic:
__abs__(...)
x.__abs__() <==> abs(x)
__and__(...)
x.__and__(y) <==> x&y
__array__(...)
sc.__array__(|type) return 0-dim array
__array_wrap__(...)
sc.__array_wrap__(obj) return scalar from array
__copy__(...)
__deepcopy__(...)
__div__(...)
x.__div__(y) <==> x/y
__divmod__(...)
x.__divmod__(y) <==> divmod(x, y)
__float__(...)
x.__float__() <==> float(x)
__floordiv__(...)
x.__floordiv__(y) <==> x//y
__hex__(...)
x.__hex__() <==> hex(x)
__int__(...)
x.__int__() <==> int(x)
__invert__(...)
x.__invert__() <==> ~x
__long__(...)
x.__long__() <==> long(x)
__lshift__(...)
x.__lshift__(y) <==> x<<y
__neg__(...)
x.__neg__() <==> -x
__nonzero__(...)
x.__nonzero__() <==> x != 0
__oct__(...)
x.__oct__() <==> oct(x)
__or__(...)
x.__or__(y) <==> x|y
__pos__(...)
x.__pos__() <==> +x
__pow__(...)
x.__pow__(y[, z]) <==> pow(x, y[, z])
__radd__(...)
x.__radd__(y) <==> y+x
__rand__(...)
x.__rand__(y) <==> y&x
__rdiv__(...)
x.__rdiv__(y) <==> y/x
__rdivmod__(...)
x.__rdivmod__(y) <==> divmod(y, x)
__reduce__(...)
__rfloordiv__(...)
x.__rfloordiv__(y) <==> y//x
__rlshift__(...)
x.__rlshift__(y) <==> y<<x
__ror__(...)
x.__ror__(y) <==> y|x
__rpow__(...)
y.__rpow__(x[, z]) <==> pow(x, y[, z])
__rrshift__(...)
x.__rrshift__(y) <==> y>>x
__rshift__(...)
x.__rshift__(y) <==> x>>y
__rsub__(...)
x.__rsub__(y) <==> y-x
__rtruediv__(...)
x.__rtruediv__(y) <==> y/x
__rxor__(...)
x.__rxor__(y) <==> y^x
__setstate__(...)
__sub__(...)
x.__sub__(y) <==> x-y
__truediv__(...)
x.__truediv__(y) <==> x/y
__xor__(...)
x.__xor__(y) <==> x^y
all(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
any(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
argmax(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
argmin(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
argsort(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
astype(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
byteswap(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class so as to
provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
choose(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
clip(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
compress(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
conj(...)
conjugate(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
copy(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
cumprod(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
cumsum(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
diagonal(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
dump(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
dumps(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
fill(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
flatten(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
getfield(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
item(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
itemset(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
max(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
mean(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
min(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
newbyteorder(...)
newbyteorder(new_order='S')
 
Return a new `dtype` with a different byte order.
 
Changes are also made in all fields and sub-arrays of the data type.
 
The `new_order` code can be any from the following:
 
* {'<', '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 : str, optional
    Byte order to force; a value from the byte order specifications
    above.  The default value ('S') results in swapping the current
    byte order. The code does a case-insensitive check on the first
    letter of `new_order` for the alternatives above.  For example,
    any of 'B' or 'b' or 'biggish' are valid to specify big-endian.
 
 
Returns
-------
new_dtype : dtype
    New `dtypeobject with the given change to the byte order.
nonzero(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
prod(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
ptp(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
put(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
ravel(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
repeat(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
reshape(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
resize(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
round(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
searchsorted(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
setfield(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
setflags(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class so as to
provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
sort(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
squeeze(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
std(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
sum(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
swapaxes(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
take(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
tofile(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
tolist(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
tostring(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
trace(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
transpose(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
var(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
view(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.

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

 
cdouble = class complex128(complexfloating, __builtin__.complex)
    Composed of two 64 bit floats
 
 
Method resolution order:
complex128
complexfloating
inexact
number
generic
__builtin__.complex
__builtin__.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>
T.__new__(S, ...) -> a new object with type S, a subtype of T

Methods inherited from generic:
__abs__(...)
x.__abs__() <==> abs(x)
__add__(...)
x.__add__(y) <==> x+y
__and__(...)
x.__and__(y) <==> x&y
__array__(...)
sc.__array__(|type) return 0-dim array
__array_wrap__(...)
sc.__array_wrap__(obj) return scalar from array
__copy__(...)
__deepcopy__(...)
__div__(...)
x.__div__(y) <==> x/y
__divmod__(...)
x.__divmod__(y) <==> divmod(x, y)
__float__(...)
x.__float__() <==> float(x)
__floordiv__(...)
x.__floordiv__(y) <==> x//y
__format__(...)
NumPy array scalar formatter
__getitem__(...)
x.__getitem__(y) <==> x[y]
__hex__(...)
x.__hex__() <==> hex(x)
__int__(...)
x.__int__() <==> int(x)
__invert__(...)
x.__invert__() <==> ~x
__long__(...)
x.__long__() <==> long(x)
__lshift__(...)
x.__lshift__(y) <==> x<<y
__mod__(...)
x.__mod__(y) <==> x%y
__mul__(...)
x.__mul__(y) <==> x*y
__neg__(...)
x.__neg__() <==> -x
__nonzero__(...)
x.__nonzero__() <==> x != 0
__oct__(...)
x.__oct__() <==> oct(x)
__or__(...)
x.__or__(y) <==> x|y
__pos__(...)
x.__pos__() <==> +x
__pow__(...)
x.__pow__(y[, z]) <==> pow(x, y[, z])
__radd__(...)
x.__radd__(y) <==> y+x
__rand__(...)
x.__rand__(y) <==> y&x
__rdiv__(...)
x.__rdiv__(y) <==> y/x
__rdivmod__(...)
x.__rdivmod__(y) <==> divmod(y, x)
__reduce__(...)
__rfloordiv__(...)
x.__rfloordiv__(y) <==> y//x
__rlshift__(...)
x.__rlshift__(y) <==> y<<x
__rmod__(...)
x.__rmod__(y) <==> y%x
__rmul__(...)
x.__rmul__(y) <==> y*x
__ror__(...)
x.__ror__(y) <==> y|x
__rpow__(...)
y.__rpow__(x[, z]) <==> pow(x, y[, z])
__rrshift__(...)
x.__rrshift__(y) <==> y>>x
__rshift__(...)
x.__rshift__(y) <==> x>>y
__rsub__(...)
x.__rsub__(y) <==> y-x
__rtruediv__(...)
x.__rtruediv__(y) <==> y/x
__rxor__(...)
x.__rxor__(y) <==> y^x
__setstate__(...)
__sub__(...)
x.__sub__(y) <==> x-y
__truediv__(...)
x.__truediv__(y) <==> x/y
__xor__(...)
x.__xor__(y) <==> x^y
all(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
any(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
argmax(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
argmin(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
argsort(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
astype(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
byteswap(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class so as to
provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
choose(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
clip(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
compress(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
conj(...)
conjugate(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
copy(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
cumprod(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
cumsum(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
diagonal(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
dump(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
dumps(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
fill(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
flatten(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
getfield(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
item(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
itemset(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
max(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
mean(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
min(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
newbyteorder(...)
newbyteorder(new_order='S')
 
Return a new `dtype` with a different byte order.
 
Changes are also made in all fields and sub-arrays of the data type.
 
The `new_order` code can be any from the following:
 
* {'<', '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 : str, optional
    Byte order to force; a value from the byte order specifications
    above.  The default value ('S') results in swapping the current
    byte order. The code does a case-insensitive check on the first
    letter of `new_order` for the alternatives above.  For example,
    any of 'B' or 'b' or 'biggish' are valid to specify big-endian.
 
 
Returns
-------
new_dtype : dtype
    New `dtypeobject with the given change to the byte order.
nonzero(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
prod(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
ptp(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
put(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
ravel(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
repeat(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
reshape(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
resize(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
round(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
searchsorted(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
setfield(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
setflags(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class so as to
provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
sort(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
squeeze(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
std(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
sum(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
swapaxes(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
take(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
tofile(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
tolist(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
tostring(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
trace(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
transpose(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
var(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
view(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.

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

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

 
cfloat = class complex128(complexfloating, __builtin__.complex)
    Composed of two 64 bit floats
 
 
Method resolution order:
complex128
complexfloating
inexact
number
generic
__builtin__.complex
__builtin__.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>
T.__new__(S, ...) -> a new object with type S, a subtype of T

Methods inherited from generic:
__abs__(...)
x.__abs__() <==> abs(x)
__add__(...)
x.__add__(y) <==> x+y
__and__(...)
x.__and__(y) <==> x&y
__array__(...)
sc.__array__(|type) return 0-dim array
__array_wrap__(...)
sc.__array_wrap__(obj) return scalar from array
__copy__(...)
__deepcopy__(...)
__div__(...)
x.__div__(y) <==> x/y
__divmod__(...)
x.__divmod__(y) <==> divmod(x, y)
__float__(...)
x.__float__() <==> float(x)
__floordiv__(...)
x.__floordiv__(y) <==> x//y
__format__(...)
NumPy array scalar formatter
__getitem__(...)
x.__getitem__(y) <==> x[y]
__hex__(...)
x.__hex__() <==> hex(x)
__int__(...)
x.__int__() <==> int(x)
__invert__(...)
x.__invert__() <==> ~x
__long__(...)
x.__long__() <==> long(x)
__lshift__(...)
x.__lshift__(y) <==> x<<y
__mod__(...)
x.__mod__(y) <==> x%y
__mul__(...)
x.__mul__(y) <==> x*y
__neg__(...)
x.__neg__() <==> -x
__nonzero__(...)
x.__nonzero__() <==> x != 0
__oct__(...)
x.__oct__() <==> oct(x)
__or__(...)
x.__or__(y) <==> x|y
__pos__(...)
x.__pos__() <==> +x
__pow__(...)
x.__pow__(y[, z]) <==> pow(x, y[, z])
__radd__(...)
x.__radd__(y) <==> y+x
__rand__(...)
x.__rand__(y) <==> y&x
__rdiv__(...)
x.__rdiv__(y) <==> y/x
__rdivmod__(...)
x.__rdivmod__(y) <==> divmod(y, x)
__reduce__(...)
__rfloordiv__(...)
x.__rfloordiv__(y) <==> y//x
__rlshift__(...)
x.__rlshift__(y) <==> y<<x
__rmod__(...)
x.__rmod__(y) <==> y%x
__rmul__(...)
x.__rmul__(y) <==> y*x
__ror__(...)
x.__ror__(y) <==> y|x
__rpow__(...)
y.__rpow__(x[, z]) <==> pow(x, y[, z])
__rrshift__(...)
x.__rrshift__(y) <==> y>>x
__rshift__(...)
x.__rshift__(y) <==> x>>y
__rsub__(...)
x.__rsub__(y) <==> y-x
__rtruediv__(...)
x.__rtruediv__(y) <==> y/x
__rxor__(...)
x.__rxor__(y) <==> y^x
__setstate__(...)
__sub__(...)
x.__sub__(y) <==> x-y
__truediv__(...)
x.__truediv__(y) <==> x/y
__xor__(...)
x.__xor__(y) <==> x^y
all(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
any(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
argmax(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
argmin(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
argsort(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
astype(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
byteswap(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class so as to
provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
choose(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
clip(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
compress(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
conj(...)
conjugate(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
copy(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
cumprod(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
cumsum(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
diagonal(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
dump(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
dumps(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
fill(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
flatten(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
getfield(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
item(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
itemset(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
max(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
mean(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
min(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
newbyteorder(...)
newbyteorder(new_order='S')
 
Return a new `dtype` with a different byte order.
 
Changes are also made in all fields and sub-arrays of the data type.
 
The `new_order` code can be any from the following:
 
* {'<', '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 : str, optional
    Byte order to force; a value from the byte order specifications
    above.  The default value ('S') results in swapping the current
    byte order. The code does a case-insensitive check on the first
    letter of `new_order` for the alternatives above.  For example,
    any of 'B' or 'b' or 'biggish' are valid to specify big-endian.
 
 
Returns
-------
new_dtype : dtype
    New `dtypeobject with the given change to the byte order.
nonzero(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
prod(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
ptp(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
put(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
ravel(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
repeat(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
reshape(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
resize(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
round(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
searchsorted(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
setfield(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
setflags(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class so as to
provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
sort(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
squeeze(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
std(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
sum(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
swapaxes(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
take(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
tofile(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
tolist(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
tostring(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
trace(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
transpose(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
var(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
view(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.

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

Methods inherited from __builtin__.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
__builtin__.object

Methods inherited from generic:
__abs__(...)
x.__abs__() <==> abs(x)
__add__(...)
x.__add__(y) <==> x+y
__and__(...)
x.__and__(y) <==> x&y
__array__(...)
sc.__array__(|type) return 0-dim array
__array_wrap__(...)
sc.__array_wrap__(obj) return scalar from array
__copy__(...)
__deepcopy__(...)
__div__(...)
x.__div__(y) <==> x/y
__divmod__(...)
x.__divmod__(y) <==> divmod(x, y)
__eq__(...)
x.__eq__(y) <==> x==y
__float__(...)
x.__float__() <==> float(x)
__floordiv__(...)
x.__floordiv__(y) <==> x//y
__format__(...)
NumPy array scalar formatter
__ge__(...)
x.__ge__(y) <==> x>=y
__getitem__(...)
x.__getitem__(y) <==> x[y]
__gt__(...)
x.__gt__(y) <==> x>y
__hex__(...)
x.__hex__() <==> hex(x)
__int__(...)
x.__int__() <==> int(x)
__invert__(...)
x.__invert__() <==> ~x
__le__(...)
x.__le__(y) <==> x<=y
__long__(...)
x.__long__() <==> long(x)
__lshift__(...)
x.__lshift__(y) <==> x<<y
__lt__(...)
x.__lt__(y) <==> x<y
__mod__(...)
x.__mod__(y) <==> x%y
__mul__(...)
x.__mul__(y) <==> x*y
__ne__(...)
x.__ne__(y) <==> x!=y
__neg__(...)
x.__neg__() <==> -x
__nonzero__(...)
x.__nonzero__() <==> x != 0
__oct__(...)
x.__oct__() <==> oct(x)
__or__(...)
x.__or__(y) <==> x|y
__pos__(...)
x.__pos__() <==> +x
__pow__(...)
x.__pow__(y[, z]) <==> pow(x, y[, z])
__radd__(...)
x.__radd__(y) <==> y+x
__rand__(...)
x.__rand__(y) <==> y&x
__rdiv__(...)
x.__rdiv__(y) <==> y/x
__rdivmod__(...)
x.__rdivmod__(y) <==> divmod(y, x)
__reduce__(...)
__repr__(...)
x.__repr__() <==> repr(x)
__rfloordiv__(...)
x.__rfloordiv__(y) <==> y//x
__rlshift__(...)
x.__rlshift__(y) <==> y<<x
__rmod__(...)
x.__rmod__(y) <==> y%x
__rmul__(...)
x.__rmul__(y) <==> y*x
__ror__(...)
x.__ror__(y) <==> y|x
__rpow__(...)
y.__rpow__(x[, z]) <==> pow(x, y[, z])
__rrshift__(...)
x.__rrshift__(y) <==> y>>x
__rshift__(...)
x.__rshift__(y) <==> x>>y
__rsub__(...)
x.__rsub__(y) <==> y-x
__rtruediv__(...)
x.__rtruediv__(y) <==> y/x
__rxor__(...)
x.__rxor__(y) <==> y^x
__setstate__(...)
__str__(...)
x.__str__() <==> str(x)
__sub__(...)
x.__sub__(y) <==> x-y
__truediv__(...)
x.__truediv__(y) <==> x/y
__xor__(...)
x.__xor__(y) <==> x^y
all(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
any(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
argmax(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
argmin(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
argsort(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
astype(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
byteswap(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class so as to
provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
choose(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
clip(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
compress(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
conj(...)
conjugate(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
copy(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
cumprod(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
cumsum(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
diagonal(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
dump(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
dumps(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
fill(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
flatten(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
getfield(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
item(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
itemset(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
max(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
mean(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
min(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
newbyteorder(...)
newbyteorder(new_order='S')
 
Return a new `dtype` with a different byte order.
 
Changes are also made in all fields and sub-arrays of the data type.
 
The `new_order` code can be any from the following:
 
* {'<', '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 : str, optional
    Byte order to force; a value from the byte order specifications
    above.  The default value ('S') results in swapping the current
    byte order. The code does a case-insensitive check on the first
    letter of `new_order` for the alternatives above.  For example,
    any of 'B' or 'b' or 'biggish' are valid to specify big-endian.
 
 
Returns
-------
new_dtype : dtype
    New `dtypeobject with the given change to the byte order.
nonzero(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
prod(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
ptp(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
put(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
ravel(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
repeat(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
reshape(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
resize(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
round(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
searchsorted(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
setfield(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
setflags(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class so as to
provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
sort(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
squeeze(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
std(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
sum(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
swapaxes(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
take(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
tofile(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
tolist(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
tostring(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
trace(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
transpose(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
var(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
view(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.

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

 
class chararray(numpy.ndarray)
    chararray(shape, itemsize=1, unicode=False, buffer=None, offset=0,
          strides=None, order=None)
 
Provides a convenient view on arrays of string and unicode values.
 
.. note::
   The `chararray` class exists for backwards compatibility with
   Numarray, it is not recommended for new development. Starting from numpy
   1.4, if one needs arrays of strings, it is recommended to use arrays of
   `dtype` `object_`, `string_` or `unicode_`, and use the free functions
   in the `numpy.char` module for fast vectorized string operations.
 
Versus a regular Numpy array of type `str` or `unicode`, this
class adds the following functionality:
 
  1) values automatically have whitespace removed from the end
     when indexed
 
  2) comparison operators automatically remove whitespace from the
     end when comparing values
 
  3) vectorized string operations are provided as methods
     (e.g. `.endswith`) and infix operators (e.g. ``"+", "*", "%"``)
 
chararrays should be created using `numpy.char.array` or
`numpy.char.asarray`, rather than this constructor directly.
 
This constructor creates the array, using `buffer` (with `offset`
and `strides`) if it is not ``None``. If `buffer` is ``None``, then
constructs a new array with `strides` in "C order", unless both
``len(shape) >= 2`` and ``order='Fortran'``, in which case `strides`
is in "Fortran order".
 
Methods
-------
astype
argsort
copy
count
decode
dump
dumps
encode
endswith
expandtabs
fill
find
flatten
getfield
index
isalnum
isalpha
isdecimal
isdigit
islower
isnumeric
isspace
istitle
isupper
item
join
ljust
lower
lstrip
nonzero
put
ravel
repeat
replace
reshape
resize
rfind
rindex
rjust
rsplit
rstrip
searchsorted
setfield
setflags
sort
split
splitlines
squeeze
startswith
strip
swapaxes
swapcase
take
title
tofile
tolist
tostring
translate
transpose
upper
view
zfill
 
Parameters
----------
shape : tuple
    Shape of the array.
itemsize : int, optional
    Length of each array element, in number of characters. Default is 1.
unicode : bool, optional
    Are the array elements of type unicode (True) or string (False).
    Default is False.
buffer : int, optional
    Memory address of the start of the array data.  Default is None,
    in which case a new array is created.
offset : int, optional
    Fixed stride displacement from the beginning of an axis?
    Default is 0. Needs to be >=0.
strides : array_like of ints, optional
    Strides for the array (see `ndarray.strides` for full description).
    Default is None.
order : {'C', 'F'}, optional
    The order in which the array data is stored in memory: 'C' ->
    "row major" order (the default), 'F' -> "column major"
    (Fortran) order.
 
Examples
--------
>>> charar = np.chararray((3, 3))
>>> charar[:] = 'a'
>>> charar
chararray([['a', 'a', 'a'],
       ['a', 'a', 'a'],
       ['a', 'a', 'a']],
      dtype='|S1')
 
>>> charar = np.chararray(charar.shape, itemsize=5)
>>> charar[:] = 'abc'
>>> charar
chararray([['abc', 'abc', 'abc'],
       ['abc', 'abc', 'abc'],
       ['abc', 'abc', 'abc']],
      dtype='|S5')
 
 
Method resolution order:
chararray
numpy.ndarray
__builtin__.object

Methods defined here:
__add__(self, other)
Return (self + other), that is string concatenation,
element-wise for a pair of array_likes of str or unicode.
 
See also
--------
add
__array_finalize__(self, obj)
__eq__(self, other)
Return (self == other) element-wise.
 
See also
--------
equal
__ge__(self, other)
Return (self >= other) element-wise.
 
See also
--------
greater_equal
__getitem__(self, obj)
__gt__(self, other)
Return (self > other) element-wise.
 
See also
--------
greater
__le__(self, other)
Return (self <= other) element-wise.
 
See also
--------
less_equal
__lt__(self, other)
Return (self < other) element-wise.
 
See also
--------
less
__mod__(self, i)
Return (self % i), that is pre-Python 2.6 string formatting
(iterpolation), element-wise for a pair of array_likes of `string_`
or `unicode_`.
 
See also
--------
mod
__mul__(self, i)
Return (self * i), that is string multiple concatenation,
element-wise.
 
See also
--------
multiply
__ne__(self, other)
Return (self != other) element-wise.
 
See also
--------
not_equal
__radd__(self, other)
Return (other + self), that is string concatenation,
element-wise for a pair of array_likes of `string_` or `unicode_`.
 
See also
--------
add
__rmod__(self, other)
__rmul__(self, i)
Return (self * i), that is string multiple concatenation,
element-wise.
 
See also
--------
multiply
argsort(self, axis=-1, kind='quicksort', order=None)
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
capitalize(self)
Return a copy of `self` with only the first character of each element
capitalized.
 
See also
--------
char.capitalize
center(self, width, fillchar=' ')
Return a copy of `self` with its elements centered in a
string of length `width`.
 
See also
--------
center
count(self, sub, start=0, end=None)
Returns an array with the number of non-overlapping occurrences of
substring `sub` in the range [`start`, `end`].
 
See also
--------
char.count
decode(self, encoding=None, errors=None)
Calls `str.decode` element-wise.
 
See also
--------
char.decode
encode(self, encoding=None, errors=None)
Calls `str.encode` element-wise.
 
See also
--------
char.encode
endswith(self, suffix, start=0, end=None)
Returns a boolean array which is `True` where the string element
in `self` ends with `suffix`, otherwise `False`.
 
See also
--------
char.endswith
expandtabs(self, tabsize=8)
Return a copy of each string element where all tab characters are
replaced by one or more spaces.
 
See also
--------
char.expandtabs
find(self, sub, start=0, end=None)
For each element, return the lowest index in the string where
substring `sub` is found.
 
See also
--------
char.find
index(self, sub, start=0, end=None)
Like `find`, but raises `ValueError` when the substring is not found.
 
See also
--------
char.index
isalnum(self)
Returns true for each element if all characters in the string
are alphanumeric and there is at least one character, false
otherwise.
 
See also
--------
char.isalnum
isalpha(self)
Returns true for each element if all characters in the string
are alphabetic and there is at least one character, false
otherwise.
 
See also
--------
char.isalpha
isdecimal(self)
For each element in `self`, return True if there are only
decimal characters in the element.
 
See also
--------
char.isdecimal
isdigit(self)
Returns true for each element if all characters in the string are
digits and there is at least one character, false otherwise.
 
See also
--------
char.isdigit
islower(self)
Returns true for each element if all cased characters in the
string are lowercase and there is at least one cased character,
false otherwise.
 
See also
--------
char.islower
isnumeric(self)
For each element in `self`, return True if there are only
numeric characters in the element.
 
See also
--------
char.isnumeric
isspace(self)
Returns true for each element if there are only whitespace
characters in the string and there is at least one character,
false otherwise.
 
See also
--------
char.isspace
istitle(self)
Returns true for each element if the element is a titlecased
string and there is at least one character, false otherwise.
 
See also
--------
char.istitle
isupper(self)
Returns true for each element if all cased characters in the
string are uppercase and there is at least one character, false
otherwise.
 
See also
--------
char.isupper
join(self, seq)
Return a string which is the concatenation of the strings in the
sequence `seq`.
 
See also
--------
char.join
ljust(self, width, fillchar=' ')
Return an array with the elements of `self` left-justified in a
string of length `width`.
 
See also
--------
char.ljust
lower(self)
Return an array with the elements of `self` converted to
lowercase.
 
See also
--------
char.lower
lstrip(self, chars=None)
For each element in `self`, return a copy with the leading characters
removed.
 
See also
--------
char.lstrip
partition(self, sep)
Partition each element in `self` around `sep`.
 
See also
--------
partition
replace(self, old, new, count=None)
For each element in `self`, return a copy of the string with all
occurrences of substring `old` replaced by `new`.
 
See also
--------
char.replace
rfind(self, sub, start=0, end=None)
For each element in `self`, return the highest index in the string
where substring `sub` is found, such that `sub` is contained
within [`start`, `end`].
 
See also
--------
char.rfind
rindex(self, sub, start=0, end=None)
Like `rfind`, but raises `ValueError` when the substring `sub` is
not found.
 
See also
--------
char.rindex
rjust(self, width, fillchar=' ')
Return an array with the elements of `self`
right-justified in a string of length `width`.
 
See also
--------
char.rjust
rpartition(self, sep)
Partition each element in `self` around `sep`.
 
See also
--------
rpartition
rsplit(self, sep=None, maxsplit=None)
For each element in `self`, return a list of the words in
the string, using `sep` as the delimiter string.
 
See also
--------
char.rsplit
rstrip(self, chars=None)
For each element in `self`, return a copy with the trailing
characters removed.
 
See also
--------
char.rstrip
split(self, sep=None, maxsplit=None)
For each element in `self`, return a list of the words in the
string, using `sep` as the delimiter string.
 
See also
--------
char.split
splitlines(self, keepends=None)
For each element in `self`, return a list of the lines in the
element, breaking at line boundaries.
 
See also
--------
char.splitlines
startswith(self, prefix, start=0, end=None)
Returns a boolean array which is `True` where the string element
in `self` starts with `prefix`, otherwise `False`.
 
See also
--------
char.startswith
strip(self, chars=None)
For each element in `self`, return a copy with the leading and
trailing characters removed.
 
See also
--------
char.strip
swapcase(self)
For each element in `self`, return a copy of the string with
uppercase characters converted to lowercase and vice versa.
 
See also
--------
char.swapcase
title(self)
For each element in `self`, return a titlecased version of the
string: words start with uppercase characters, all remaining cased
characters are lowercase.
 
See also
--------
char.title
translate(self, table, deletechars=None)
For each element in `self`, return a copy of the string where
all characters occurring in the optional argument
`deletechars` are removed, and the remaining characters have
been mapped through the given translation table.
 
See also
--------
char.translate
upper(self)
Return an array with the elements of `self` converted to
uppercase.
 
See also
--------
char.upper
zfill(self, width)
Return the numeric string left-filled with zeros in a string of
length `width`.
 
See also
--------
char.zfill

Static methods defined here:
__new__(subtype, shape, itemsize=1, unicode=False, buffer=None, offset=0, strides=None, order='C')

Data descriptors defined here:
__dict__
dictionary for instance variables (if defined)

Methods inherited from numpy.ndarray:
__abs__(...)
x.__abs__() <==> abs(x)
__and__(...)
x.__and__(y) <==> x&y
__array__(...)
a.__array__(|dtype) -> reference if type unchanged, copy otherwise.
 
Returns either a new reference to self if dtype is not given or a new array
of provided data type if dtype is different from the current dtype of the
array.
__array_prepare__(...)
a.__array_prepare__(obj) -> Object of same type as ndarray object obj.
__array_wrap__(...)
a.__array_wrap__(obj) -> Object of same type as ndarray object a.
__contains__(...)
x.__contains__(y) <==> y in x
__copy__(...)
a.__copy__([order])
 
Return a copy of the array.
 
Parameters
----------
order : {'C', 'F', 'A'}, optional
    If order is 'C' (False) then the result is contiguous (default).
    If order is 'Fortran' (True) then the result has fortran order.
    If order is 'Any' (None) then the result has fortran order
    only if the array already is in fortran order.
__deepcopy__(...)
a.__deepcopy__() -> Deep copy of array.
 
Used if copy.deepcopy is called on an array.
__delitem__(...)
x.__delitem__(y) <==> del x[y]
__delslice__(...)
x.__delslice__(i, j) <==> del x[i:j]
 
Use of negative indices is not supported.
__div__(...)
x.__div__(y) <==> x/y
__divmod__(...)
x.__divmod__(y) <==> divmod(x, y)
__float__(...)
x.__float__() <==> float(x)
__floordiv__(...)
x.__floordiv__(y) <==> x//y
__getslice__(...)
x.__getslice__(i, j) <==> x[i:j]
 
Use of negative indices is not supported.
__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
__len__(...)
x.__len__() <==> len(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])
__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
__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)
 
Returns True if any of the elements of `a` evaluate to True.
 
Refer to `numpy.any` for full documentation.
 
See Also
--------
numpy.any : equivalent function
argmax(...)
a.argmax(axis=None, out=None)
 
Return indices of the maximum values along the given axis.
 
Refer to `numpy.argmax` for full documentation.
 
See Also
--------
numpy.argmax : equivalent function
argmin(...)
a.argmin(axis=None, out=None)
 
Return indices of the minimum values along the given axis of `a`.
 
Refer to `numpy.argmin` for detailed documentation.
 
See Also
--------
numpy.argmin : equivalent function
argpartition(...)
a.argpartition(kth, axis=-1, kind='quickselect', order=None)
 
Returns the indices that would partition this array.
 
Refer to `numpy.argpartition` for full documentation.
 
.. versionadded:: 1.8.0
 
See Also
--------
numpy.argpartition : equivalent function
astype(...)
a.astype(dtype, order='K', casting='unsafe', subok=True, copy=True)
 
Copy of the array, cast to a specified type.
 
Parameters
----------
dtype : str or dtype
    Typecode or data-type to which the array is cast.
order : {'C', 'F', 'A', 'K'}, optional
    Controls the memory layout order of the result.
    'C' means C order, 'F' means Fortran order, 'A'
    means 'F' order if all the arrays are Fortran contiguous,
    'C' order otherwise, and 'K' means as close to the
    order the array elements appear in memory as possible.
    Default is 'K'.
casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
    Controls what kind of data casting may occur. Defaults to 'unsafe'
    for backwards compatibility.
 
      * 'no' means the data types should not be cast at all.
      * 'equiv' means only byte-order changes are allowed.
      * 'safe' means only casts which can preserve values are allowed.
      * 'same_kind' means only safe casts or casts within a kind,
        like float64 to float32, are allowed.
      * 'unsafe' means any data conversions may be done.
subok : bool, optional
    If True, then sub-classes will be passed-through (default), otherwise
    the returned array will be forced to be a base-class array.
copy : bool, optional
    By default, astype always returns a newly allocated array. If this
    is set to false, and the `dtype`, `order`, and `subok`
    requirements are satisfied, the input array is returned instead
    of a copy.
 
Returns
-------
arr_t : ndarray
    Unless `copy` is False and the other conditions for returning the input
    array are satisfied (see description for `copy` input paramter), `arr_t`
    is a new array of the same shape as the input array, with dtype, order
    given by `dtype`, `order`.
 
Raises
------
ComplexWarning
    When casting from complex to float or int. To avoid this,
    one should use ``a.real.astype(t)``.
 
Examples
--------
>>> x = np.array([1, 2, 2.5])
>>> x
array([ 1. ,  2. ,  2.5])
 
>>> x.astype(int)
array([1, 2, 2])
byteswap(...)
a.byteswap(inplace)
 
Swap the bytes of the array elements
 
Toggle between low-endian and big-endian data representation by
returning a byteswapped array, optionally swapped in-place.
 
Parameters
----------
inplace : bool, optional
    If ``True``, swap bytes in-place, default is ``False``.
 
Returns
-------
out : ndarray
    The byteswapped array. If `inplace` is ``True``, this is
    a view to self.
 
Examples
--------
>>> A = np.array([1, 256, 8755], dtype=np.int16)
>>> map(hex, A)
['0x1', '0x100', '0x2233']
>>> A.byteswap(True)
array([  256,     1, 13090], dtype=int16)
>>> map(hex, A)
['0x100', '0x1', '0x3322']
 
Arrays of strings are not swapped
 
>>> A = np.array(['ceg', 'fac'])
>>> A.byteswap()
array(['ceg', 'fac'],
      dtype='|S3')
choose(...)
a.choose(choices, out=None, mode='raise')
 
Use an index array to construct a new array from a set of choices.
 
Refer to `numpy.choose` for full documentation.
 
See Also
--------
numpy.choose : equivalent function
clip(...)
a.clip(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()
 
Complex-conjugate all elements.
 
Refer to `numpy.conjugate` for full documentation.
 
See Also
--------
numpy.conjugate : equivalent function
conjugate(...)
a.conjugate()
 
Return the complex conjugate, element-wise.
 
Refer to `numpy.conjugate` for full documentation.
 
See Also
--------
numpy.conjugate : equivalent function
copy(...)
a.copy(order='C')
 
Return a copy of the array.
 
Parameters
----------
order : {'C', 'F', 'A', 'K'}, optional
    Controls the memory layout of the copy. 'C' means C-order,
    'F' means F-order, 'A' means 'F' if `a` is Fortran contiguous,
    'C' otherwise. 'K' means match the layout of `a` as closely
    as possible. (Note that this function and :func:numpy.copy are very
    similar, but have different default values for their order=
    arguments.)
 
See also
--------
numpy.copy
numpy.copyto
 
Examples
--------
>>> x = np.array([[1,2,3],[4,5,6]], order='F')
 
>>> y = x.copy()
 
>>> x.fill(0)
 
>>> x
array([[0, 0, 0],
       [0, 0, 0]])
 
>>> y
array([[1, 2, 3],
       [4, 5, 6]])
 
>>> y.flags['C_CONTIGUOUS']
True
cumprod(...)
a.cumprod(axis=None, dtype=None, out=None)
 
Return the cumulative product of the elements along the given axis.
 
Refer to `numpy.cumprod` for full documentation.
 
See Also
--------
numpy.cumprod : equivalent function
cumsum(...)
a.cumsum(axis=None, dtype=None, out=None)
 
Return the cumulative sum of the elements along the given axis.
 
Refer to `numpy.cumsum` for full documentation.
 
See Also
--------
numpy.cumsum : equivalent function
diagonal(...)
a.diagonal(offset=0, axis1=0, axis2=1)
 
Return specified diagonals.
 
Refer to :func:`numpy.diagonal` for full documentation.
 
See Also
--------
numpy.diagonal : equivalent function
dot(...)
a.dot(b, out=None)
 
Dot product of two arrays.
 
Refer to `numpy.dot` for full documentation.
 
See Also
--------
numpy.dot : equivalent function
 
Examples
--------
>>> a = np.eye(2)
>>> b = np.ones((2, 2)) * 2
>>> a.dot(b)
array([[ 2.,  2.],
       [ 2.,  2.]])
 
This array method can be conveniently chained:
 
>>> a.dot(b).dot(b)
array([[ 8.,  8.],
       [ 8.,  8.]])
dump(...)
a.dump(file)
 
Dump a pickle of the array to the specified file.
The array can be read back with pickle.load or numpy.load.
 
Parameters
----------
file : str
    A string naming the dump file.
dumps(...)
a.dumps()
 
Returns the pickle of the array as a string.
pickle.loads or numpy.loads will convert the string back to an array.
 
Parameters
----------
None
fill(...)
a.fill(value)
 
Fill the array with a scalar value.
 
Parameters
----------
value : scalar
    All elements of `a` will be assigned this value.
 
Examples
--------
>>> a = np.array([1, 2])
>>> a.fill(0)
>>> a
array([0, 0])
>>> a = np.empty(2)
>>> a.fill(1)
>>> a
array([ 1.,  1.])
flatten(...)
a.flatten(order='C')
 
Return a copy of the array collapsed into one dimension.
 
Parameters
----------
order : {'C', 'F', 'A'}, optional
    Whether to flatten in C (row-major), Fortran (column-major) order,
    or preserve the C/Fortran ordering from `a`.
    The default is 'C'.
 
Returns
-------
y : ndarray
    A copy of the input array, flattened to one dimension.
 
See Also
--------
ravel : Return a flattened array.
flat : A 1-D flat iterator over the array.
 
Examples
--------
>>> a = np.array([[1,2], [3,4]])
>>> a.flatten()
array([1, 2, 3, 4])
>>> a.flatten('F')
array([1, 3, 2, 4])
getfield(...)
a.getfield(dtype, offset=0)
 
Returns a field of the given array as a certain type.
 
A field is a view of the array data with a given data-type. The values in
the view are determined by the given type and the offset into the current
array in bytes. The offset needs to be such that the view dtype fits in the
array dtype; for example an array of dtype complex128 has 16-byte elements.
If taking a view with a 32-bit integer (4 bytes), the offset needs to be
between 0 and 12 bytes.
 
Parameters
----------
dtype : str or dtype
    The data type of the view. The dtype size of the view can not be larger
    than that of the array itself.
offset : int
    Number of bytes to skip before beginning the element view.
 
Examples
--------
>>> x = np.diag([1.+1.j]*2)
>>> x[1, 1] = 2 + 4.j
>>> x
array([[ 1.+1.j,  0.+0.j],
       [ 0.+0.j,  2.+4.j]])
>>> x.getfield(np.float64)
array([[ 1.,  0.],
       [ 0.,  2.]])
 
By choosing an offset of 8 bytes we can select the complex part of the
array for our view:
 
>>> x.getfield(np.float64, offset=8)
array([[ 1.,  0.],
   [ 0.,  4.]])
item(...)
a.item(*args)
 
Copy an element of an array to a standard Python scalar and return it.
 
Parameters
----------
\*args : Arguments (variable number and type)
 
    * none: in this case, the method only works for arrays
      with one element (`a.size == 1`), which element is
      copied into a standard Python scalar object and returned.
 
    * int_type: this argument is interpreted as a flat index into
      the array, specifying which element to copy and return.
 
    * tuple of int_types: functions as does a single int_type argument,
      except that the argument is interpreted as an nd-index into the
      array.
 
Returns
-------
z : Standard Python scalar object
    A copy of the specified element of the array as a suitable
    Python scalar
 
Notes
-----
When the data type of `a` is longdouble or clongdoubleitem() returns
a scalar array object because there is no available Python scalar that
would not lose information. Void arrays return a buffer object for item(),
unless fields are defined, in which case a tuple is returned.
 
`item` is very similar to a[args], except, instead of an array scalar,
a standard Python scalar is returned. This can be useful for speeding up
access to elements of the array and doing arithmetic on elements of the
array using Python's optimized math.
 
Examples
--------
>>> x = np.random.randint(9, size=(3, 3))
>>> x
array([[3, 1, 7],
       [2, 8, 3],
       [8, 5, 3]])
>>> x.item(3)
2
>>> x.item(7)
5
>>> x.item((0, 1))
1
>>> x.item((2, 2))
3
itemset(...)
a.itemset(*args)
 
Insert scalar into an array (scalar is cast to array's dtype, if possible)
 
There must be at least 1 argument, and define the last argument
as *item*.  Then, ``a.itemset(*args)`` is equivalent to but faster
than ``a[args] = item``.  The item should be a scalar value and `args`
must select a single item in the array `a`.
 
Parameters
----------
\*args : Arguments
    If one argument: a scalar, only used in case `a` is of size 1.
    If two arguments: the last argument is the value to be set
    and must be a scalar, the first argument specifies a single array
    element location. It is either an int or a tuple.
 
Notes
-----
Compared to indexing syntax, `itemset` provides some speed increase
for placing a scalar into a particular location in an `ndarray`,
if you must do this.  However, generally this is discouraged:
among other problems, it complicates the appearance of the code.
Also, when using `itemset` (and `item`) inside a loop, be sure
to assign the methods to a local variable to avoid the attribute
look-up at each loop iteration.
 
Examples
--------
>>> x = np.random.randint(9, size=(3, 3))
>>> x
array([[3, 1, 7],
       [2, 8, 3],
       [8, 5, 3]])
>>> x.itemset(4, 0)
>>> x.itemset((2, 2), 9)
>>> x
array([[3, 1, 7],
       [2, 0, 3],
       [8, 5, 9]])
max(...)
a.max(axis=None, out=None)
 
Return the maximum along a given axis.
 
Refer to `numpy.amax` for full documentation.
 
See Also
--------
numpy.amax : equivalent function
mean(...)
a.mean(axis=None, dtype=None, out=None)
 
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)
 
Change shape and size of array in-place.
 
Parameters
----------
new_shape : tuple of ints, or `n` ints
    Shape of resized array.
refcheck : bool, optional
    If False, reference count will not be checked. Default is True.
 
Returns
-------
None
 
Raises
------
ValueError
    If `a` does not own its own data or references or views to it exist,
    and the data memory must be changed.
 
SystemError
    If the `order` keyword argument is specified. This behaviour is a
    bug in NumPy.
 
See Also
--------
resize : Return a new array with the specified shape.
 
Notes
-----
This reallocates space for the data area if necessary.
 
Only contiguous arrays (data elements consecutive in memory) can be
resized.
 
The purpose of the reference count check is to make sure you
do not use this array as a buffer for another Python object and then
reallocate the memory. However, reference counts can increase in
other ways so if you are sure that you have not shared the memory
for this array with another Python object, then you may safely set
`refcheck` to False.
 
Examples
--------
Shrinking an array: array is flattened (in the order that the data are
stored in memory), resized, and reshaped:
 
>>> a = np.array([[0, 1], [2, 3]], order='C')
>>> a.resize((2, 1))
>>> a
array([[0],
       [1]])
 
>>> a = np.array([[0, 1], [2, 3]], order='F')
>>> a.resize((2, 1))
>>> a
array([[0],
       [2]])
 
Enlarging an array: as above, but missing entries are filled with zeros:
 
>>> b = np.array([[0, 1], [2, 3]])
>>> b.resize(2, 3) # new_shape parameter doesn't have to be a tuple
>>> b
array([[0, 1, 2],
       [3, 0, 0]])
 
Referencing an array prevents resizing...
 
>>> c = a
>>> a.resize((1, 1))
Traceback (most recent call last):
...
ValueError: cannot resize an array that has been referenced ...
 
Unless `refcheck` is False:
 
>>> a.resize((1, 1), refcheck=False)
>>> a
array([[0]])
>>> c
array([[0]])
round(...)
a.round(decimals=0, out=None)
 
Return `a` with each element rounded to the given number of decimals.
 
Refer to `numpy.around` for full documentation.
 
See Also
--------
numpy.around : equivalent function
searchsorted(...)
a.searchsorted(v, side='left', sorter=None)
 
Find indices where elements of v should be inserted in a to maintain order.
 
For full documentation, see `numpy.searchsorted`
 
See Also
--------
numpy.searchsorted : equivalent function
setfield(...)
a.setfield(val, dtype, offset=0)
 
Put a value into a specified place in a field defined by a data-type.
 
Place `val` into `a`'s field defined by `dtype` and beginning `offset`
bytes into the field.
 
Parameters
----------
val : object
    Value to be placed in field.
dtype : dtype object
    Data-type of the field in which to place `val`.
offset : int, optional
    The number of bytes into the field at which to place `val`.
 
Returns
-------
None
 
See Also
--------
getfield
 
Examples
--------
>>> x = np.eye(3)
>>> x.getfield(np.float64)
array([[ 1.,  0.,  0.],
       [ 0.,  1.,  0.],
       [ 0.,  0.,  1.]])
>>> x.setfield(3, np.int32)
>>> x.getfield(np.int32)
array([[3, 3, 3],
       [3, 3, 3],
       [3, 3, 3]])
>>> x
array([[  1.00000000e+000,   1.48219694e-323,   1.48219694e-323],
       [  1.48219694e-323,   1.00000000e+000,   1.48219694e-323],
       [  1.48219694e-323,   1.48219694e-323,   1.00000000e+000]])
>>> x.setfield(np.eye(3), np.int32)
>>> x
array([[ 1.,  0.,  0.],
       [ 0.,  1.,  0.],
       [ 0.,  0.,  1.]])
setflags(...)
a.setflags(write=None, align=None, uic=None)
 
Set array flags WRITEABLE, ALIGNED, and UPDATEIFCOPY, respectively.
 
These Boolean-valued flags affect how numpy interprets the memory
area used by `a` (see Notes below). The ALIGNED flag can only
be set to True if the data is actually aligned according to the type.
The UPDATEIFCOPY flag can never be set to True. The flag WRITEABLE
can only be set to True if the array owns its own memory, or the
ultimate owner of the memory exposes a writeable buffer interface,
or is a string. (The exception for string is made so that unpickling
can be done without copying memory.)
 
Parameters
----------
write : bool, optional
    Describes whether or not `a` can be written to.
align : bool, optional
    Describes whether or not `a` is aligned properly for its type.
uic : bool, optional
    Describes whether or not `a` is a copy of another "base" array.
 
Notes
-----
Array flags provide information about how the memory area used
for the array is to be interpreted. There are 6 Boolean flags
in use, only three of which can be changed by the user:
UPDATEIFCOPY, WRITEABLE, and ALIGNED.
 
WRITEABLE (W) the data area can be written to;
 
ALIGNED (A) the data and strides are aligned appropriately for the hardware
(as determined by the compiler);
 
UPDATEIFCOPY (U) this array is a copy of some other array (referenced
by .base). When this array is deallocated, the base array will be
updated with the contents of this array.
 
All flags can be accessed using their first (upper case) letter as well
as the full name.
 
Examples
--------
>>> y
array([[3, 1, 7],
       [2, 0, 0],
       [8, 5, 9]])
>>> y.flags
  C_CONTIGUOUS : True
  F_CONTIGUOUS : False
  OWNDATA : True
  WRITEABLE : True
  ALIGNED : True
  UPDATEIFCOPY : False
>>> y.setflags(write=0, align=0)
>>> y.flags
  C_CONTIGUOUS : True
  F_CONTIGUOUS : False
  OWNDATA : True
  WRITEABLE : False
  ALIGNED : False
  UPDATEIFCOPY : False
>>> y.setflags(uic=1)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: cannot set UPDATEIFCOPY flag to True
sort(...)
a.sort(axis=-1, kind='quicksort', order=None)
 
Sort an array, in-place.
 
Parameters
----------
axis : int, optional
    Axis along which to sort. Default is -1, which means sort along the
    last axis.
kind : {'quicksort', 'mergesort', 'heapsort'}, optional
    Sorting algorithm. Default is 'quicksort'.
order : 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.
partition: Partial sort.
 
Notes
-----
See ``sort`` for notes on the different sorting algorithms.
 
Examples
--------
>>> a = np.array([[1,4], [3,1]])
>>> a.sort(axis=1)
>>> a
array([[1, 4],
       [1, 3]])
>>> a.sort(axis=0)
>>> a
array([[1, 3],
       [1, 4]])
 
Use the `order` keyword to specify a field to use when sorting a
structured array:
 
>>> a = np.array([('a', 2), ('c', 1)], dtype=[('x', 'S1'), ('y', int)])
>>> a.sort(order='y')
>>> a
array([('c', 1), ('a', 2)],
      dtype=[('x', '|S1'), ('y', '<i4')])
squeeze(...)
a.squeeze(axis=None)
 
Remove single-dimensional entries from the shape of `a`.
 
Refer to `numpy.squeeze` for full documentation.
 
See Also
--------
numpy.squeeze : equivalent function
std(...)
a.std(axis=None, dtype=None, out=None, ddof=0)
 
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 (default).
 
Data is always written in 'C' order, independent of the order of `a`.
The data produced by this method can be recovered using the function
fromfile().
 
Parameters
----------
fid : file or str
    An open file object, or a string containing a filename.
sep : str
    Separator between array items for text output.
    If "" (empty), a binary file is written, equivalent to
    ``file.write(a.tostring())``.
format : str
    Format string for text file output.
    Each entry in the array is formatted to text by first converting
    it to the closest Python type, and then using "format" % item.
 
Notes
-----
This is a convenience function for quick storage of array data.
Information on endianness and precision is lost, so this method is not a
good choice for files intended to archive data or transport data between
machines with different endianness. Some of these problems can be overcome
by outputting the data as text files, at the expense of speed and file
size.
tolist(...)
a.tolist()
 
Return the array as a (possibly nested) list.
 
Return a copy of the array data as a (nested) Python list.
Data items are converted to the nearest compatible Python type.
 
Parameters
----------
none
 
Returns
-------
y : list
    The possibly nested list of array elements.
 
Notes
-----
The array may be recreated, ``a = np.array(a.tolist())``.
 
Examples
--------
>>> a = np.array([1, 2])
>>> a.tolist()
[1, 2]
>>> a = np.array([[1, 2], [3, 4]])
>>> list(a)
[array([1, 2]), array([3, 4])]
>>> a.tolist()
[[1, 2], [3, 4]]
tostring(...)
a.tostring(order='C')
 
Construct a Python string containing the raw data bytes in the array.
 
Constructs a Python string showing a copy of the raw contents of
data memory. The string can be produced in either 'C' or 'Fortran',
or 'Any' order (the default is 'C'-order). 'Any' order means C-order
unless the F_CONTIGUOUS flag in the array is set, in which case it
means 'Fortran' order.
 
Parameters
----------
order : {'C', 'F', None}, optional
    Order of the data for multidimensional arrays:
    C, Fortran, or the same as for the original array.
 
Returns
-------
s : str
    A Python string exhibiting a copy of `a`'s raw data.
 
Examples
--------
>>> x = np.array([[0, 1], [2, 3]])
>>> x.tostring()
'\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00'
>>> x.tostring('C') == x.tostring()
True
>>> x.tostring('F')
'\x00\x00\x00\x00\x02\x00\x00\x00\x01\x00\x00\x00\x03\x00\x00\x00'
trace(...)
a.trace(offset=0, axis1=0, axis2=1, dtype=None, out=None)
 
Return the sum along diagonals of the array.
 
Refer to `numpy.trace` for full documentation.
 
See Also
--------
numpy.trace : equivalent function
transpose(...)
a.transpose(*axes)
 
Returns a view of the array with axes transposed.
 
For a 1-D array, this has no effect. (To change between column and
row vectors, first cast the 1-D array into a matrix object.)
For a 2-D array, this is the usual matrix transpose.
For an n-D array, if axes are given, their order indicates how the
axes are permuted (see Examples). If axes are not provided and
``a.shape = (i[0], i[1], ... i[n-2], i[n-1])``, then
``a.transpose().shape = (i[n-1], i[n-2], ... i[1], i[0])``.
 
Parameters
----------
axes : None, tuple of ints, or `n` ints
 
 * None or no argument: reverses the order of the axes.
 
 * tuple of ints: `i` in the `j`-th place in the tuple means `a`'s
   `i`-th axis becomes `a.transpose()`'s `j`-th axis.
 
 * `n` ints: same as an n-tuple of the same ints (this form is
   intended simply as a "convenience" alternative to the tuple form)
 
Returns
-------
out : ndarray
    View of `a`, with axes suitably permuted.
 
See Also
--------
ndarray.T : Array property returning the array transposed.
 
Examples
--------
>>> a = np.array([[1, 2], [3, 4]])
>>> a
array([[1, 2],
       [3, 4]])
>>> a.transpose()
array([[1, 3],
       [2, 4]])
>>> a.transpose((1, 0))
array([[1, 3],
       [2, 4]])
>>> a.transpose(1, 0)
array([[1, 3],
       [2, 4]])
var(...)
a.var(axis=None, dtype=None, out=None, ddof=0)
 
Returns the variance of the array elements, along given axis.
 
Refer to `numpy.var` for full documentation.
 
See Also
--------
numpy.var : equivalent function
view(...)
a.view(dtype=None, type=None)
 
New view of array with the same data.
 
Parameters
----------
dtype : data-type or ndarray sub-class, optional
    Data-type descriptor of the returned view, e.g., float32 or int16. The
    default, None, results in the view having the same data-type as `a`.
    This argument can also be specified as an ndarray sub-class, which
    then specifies the type of the returned object (this is equivalent to
    setting the ``type`` parameter).
type : Python type, optional
    Type of the returned view, e.g., ndarray or matrix.  Again, the
    default None results in type preservation.
 
Notes
-----
``a.view()`` is used two different ways:
 
``a.view(some_dtype)`` or ``a.view(dtype=some_dtype)`` constructs a view
of the array's memory with a different data-type.  This can cause a
reinterpretation of the bytes of memory.
 
``a.view(ndarray_subclass)`` or ``a.view(type=ndarray_subclass)`` just
returns an instance of `ndarray_subclass` that looks at the same array
(same shape, dtype, etc.)  This does not cause a reinterpretation of the
memory.
 
For ``a.view(some_dtype)``, if ``some_dtype`` has a different number of
bytes per entry than the previous dtype (for example, converting a
regular array to a structured array), then the behavior of the view
cannot be predicted just from the superficial appearance of ``a`` (shown
by ``print(a)``). It also depends on exactly how ``a`` is stored in
memory. Therefore if ``a`` is C-ordered versus fortran-ordered, versus
defined as a slice or transpose, etc., the view may give different
results.
 
 
Examples
--------
>>> x = np.array([(1, 2)], dtype=[('a', np.int8), ('b', np.int8)])
 
Viewing array data using a different type and dtype:
 
>>> y = x.view(dtype=np.int16, type=np.matrix)
>>> y
matrix([[513]], dtype=int16)
>>> print type(y)
<class 'numpy.matrixlib.defmatrix.matrix'>
 
Creating a view on a structured array so it can be used in calculations
 
>>> x = np.array([(1, 2),(3,4)], dtype=[('a', np.int8), ('b', np.int8)])
>>> xv = x.view(dtype=np.int8).reshape(-1,2)
>>> xv
array([[1, 2],
       [3, 4]], dtype=int8)
>>> xv.mean(0)
array([ 2.,  3.])
 
Making changes to the view changes the underlying array
 
>>> xv[0,1] = 20
>>> print x
[(1, 20) (3, 4)]
 
Using a view to convert an array to a record array:
 
>>> z = x.view(np.recarray)
>>> z.a
array([1], dtype=int8)
 
Views share data:
 
>>> x[0] = (9, 10)
>>> z[0]
(9, 10)
 
Views that change the dtype size (bytes per entry) should normally be
avoided on arrays defined by slices, transposes, fortran-ordering, etc.:
 
>>> x = np.array([[1,2,3],[4,5,6]], dtype=np.int16)
>>> y = x[:, 0:2]
>>> y
array([[1, 2],
       [4, 5]], dtype=int16)
>>> y.view(dtype=[('width', np.int16), ('length', np.int16)])
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: new type not compatible with array.
>>> z = y.copy()
>>> z.view(dtype=[('width', np.int16), ('length', np.int16)])
array([[(1, 2)],
       [(4, 5)]], dtype=[('width', '<i2'), ('length', '<i2')])

Data descriptors inherited from numpy.ndarray:
T
Same as self.transpose(), except that self is returned if
self.ndim < 2.
 
Examples
--------
>>> x = np.array([[1.,2.],[3.,4.]])
>>> x
array([[ 1.,  2.],
       [ 3.,  4.]])
>>> x.T
array([[ 1.,  3.],
       [ 2.,  4.]])
>>> x = np.array([1.,2.,3.,4.])
>>> x
array([ 1.,  2.,  3.,  4.])
>>> x.T
array([ 1.,  2.,  3.,  4.])
__array_interface__
Array protocol: Python side.
__array_priority__
Array priority.
__array_struct__
Array protocol: C-struct side.
base
Base object if memory is from some other object.
 
Examples
--------
The base of an array that owns its memory is None:
 
>>> x = np.array([1,2,3,4])
>>> x.base is None
True
 
Slicing creates a view, whose memory is shared with x:
 
>>> y = x[2:]
>>> y.base is x
True
ctypes
An object to simplify the interaction of the array with the ctypes
module.
 
This attribute creates an object that makes it easier to use arrays
when calling shared libraries with the ctypes module. The returned
object has, among others, data, shape, and strides attributes (see
Notes below) which themselves return ctypes objects that can be used
as arguments to a shared library.
 
Parameters
----------
None
 
Returns
-------
c : Python object
    Possessing attributes data, shape, strides, etc.
 
See Also
--------
numpy.ctypeslib
 
Notes
-----
Below are the public attributes of this object which were documented
in "Guide to NumPy" (we have omitted undocumented public attributes,
as well as documented private attributes):
 
* data: A pointer to the memory area of the array as a Python integer.
  This memory area may contain data that is not aligned, or not in correct
  byte-order. The memory area may not even be writeable. The array
  flags and data-type of this array should be respected when passing this
  attribute to arbitrary C-code to avoid trouble that can include Python
  crashing. User Beware! The value of this attribute is exactly the same
  as self._array_interface_['data'][0].
 
* shape (c_intp*self.ndim): A ctypes array of length self.ndim where
  the basetype is the C-integer corresponding to dtype('p') on this
  platform. This base-type could be c_int, c_long, or c_longlong
  depending on the platform. The c_intp type is defined accordingly in
  numpy.ctypeslib. The ctypes array contains the shape of the underlying
  array.
 
* strides (c_intp*self.ndim): A ctypes array of length self.ndim where
  the basetype is the same as for the shape attribute. This ctypes array
  contains the strides information from the underlying array. This strides
  information is important for showing how many bytes must be jumped to
  get to the next element in the array.
 
* data_as(obj): Return the data pointer cast to a particular c-types object.
  For example, calling self._as_parameter_ is equivalent to
  self.data_as(ctypes.c_void_p). Perhaps you want to use the data as a
  pointer to a ctypes array of floating-point data:
  self.data_as(ctypes.POINTER(ctypes.c_double)).
 
* shape_as(obj): Return the shape tuple as an array of some other c-types
  type. For example: self.shape_as(ctypes.c_short).
 
* strides_as(obj): Return the strides tuple as an array of some other
  c-types type. For example: self.strides_as(ctypes.c_longlong).
 
Be careful using the ctypes attribute - especially on temporary
arrays or arrays constructed on the fly. For example, calling
``(a+b).ctypes.data_as(ctypes.c_void_p)`` returns a pointer to memory
that is invalid because the array created as (a+b) is deallocated
before the next Python statement. You can avoid this problem using
either ``c=a+b`` or ``ct=(a+b).ctypes``. In the latter case, ct will
hold a reference to the array until ct is deleted or re-assigned.
 
If the ctypes module is not available, then the ctypes attribute
of array objects still returns something useful, but ctypes objects
are not returned and errors may be raised instead. In particular,
the object will still have the as parameter attribute which will
return an integer equal to the data attribute.
 
Examples
--------
>>> import ctypes
>>> x
array([[0, 1],
       [2, 3]])
>>> x.ctypes.data
30439712
>>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_long))
<ctypes.LP_c_long object at 0x01F01300>
>>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_long)).contents
c_long(0)
>>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_longlong)).contents
c_longlong(4294967296L)
>>> x.ctypes.shape
<numpy.core._internal.c_long_Array_2 object at 0x01FFD580>
>>> x.ctypes.shape_as(ctypes.c_long)
<numpy.core._internal.c_long_Array_2 object at 0x01FCE620>
>>> x.ctypes.strides
<numpy.core._internal.c_long_Array_2 object at 0x01FCE620>
>>> x.ctypes.strides_as(ctypes.c_longlong)
<numpy.core._internal.c_longlong_Array_2 object at 0x01F01300>
data
Python buffer object pointing to the start of the array's data.
dtype
Data-type of the array's elements.
 
Parameters
----------
None
 
Returns
-------
d : numpy dtype object
 
See Also
--------
numpy.dtype
 
Examples
--------
>>> x
array([[0, 1],
       [2, 3]])
>>> x.dtype
dtype('int32')
>>> type(x.dtype)
<type 'numpy.dtype'>
flags
Information about the memory layout of the array.
 
Attributes
----------
C_CONTIGUOUS (C)
    The data is in a single, C-style contiguous segment.
F_CONTIGUOUS (F)
    The data is in a single, Fortran-style contiguous segment.
OWNDATA (O)
    The array owns the memory it uses or borrows it from another object.
WRITEABLE (W)
    The data area can be written to.  Setting this to False locks
    the data, making it read-only.  A view (slice, etc.) inherits WRITEABLE
    from its base array at creation time, but a view of a writeable
    array may be subsequently locked while the base array remains writeable.
    (The opposite is not true, in that a view of a locked array may not
    be made writeable.  However, currently, locking a base object does not
    lock any views that already reference it, so under that circumstance it
    is possible to alter the contents of a locked array via a previously
    created writeable view onto it.)  Attempting to change a non-writeable
    array raises a RuntimeError exception.
ALIGNED (A)
    The data and all elements are aligned appropriately for the hardware.
UPDATEIFCOPY (U)
    This array is a copy of some other array. When this array is
    deallocated, the base array will be updated with the contents of
    this array.
FNC
    F_CONTIGUOUS and not C_CONTIGUOUS.
FORC
    F_CONTIGUOUS or C_CONTIGUOUS (one-segment test).
BEHAVED (B)
    ALIGNED and WRITEABLE.
CARRAY (CA)
    BEHAVED and C_CONTIGUOUS.
FARRAY (FA)
    BEHAVED and F_CONTIGUOUS and not C_CONTIGUOUS.
 
Notes
-----
The `flags` object can be accessed dictionary-like (as in ``a.flags['WRITEABLE']``),
or by using lowercased attribute names (as in ``a.flags.writeable``). Short flag
names are only supported in dictionary access.
 
Only the UPDATEIFCOPY, WRITEABLE, and ALIGNED flags can be changed by
the user, via direct assignment to the attribute or dictionary entry,
or by calling `ndarray.setflags`.
 
The array flags cannot be set arbitrarily:
 
- UPDATEIFCOPY can only be set ``False``.
- ALIGNED can only be set ``True`` if the data is truly aligned.
- WRITEABLE can only be set ``True`` if the array owns its own memory
  or the ultimate owner of the memory exposes a writeable buffer
  interface or is a string.
 
Arrays can be both C-style and Fortran-style contiguous simultaneously.
This is clear for 1-dimensional arrays, but can also be true for higher
dimensional arrays.
 
Even for contiguous arrays a stride for a given dimension
``arr.strides[dim]`` may be *arbitrary* if ``arr.shape[dim] == 1``
or the array has no elements.
It does *not* generally hold that ``self.strides[-1] == self.itemsize``
for C-style contiguous arrays or ``self.strides[0] == self.itemsize`` for
Fortran-style contiguous arrays is true.
flat
A 1-D iterator over the array.
 
This is a `numpy.flatiter` instance, which acts similarly to, but is not
a subclass of, Python's built-in iterator object.
 
See Also
--------
flatten : Return a copy of the array collapsed into one dimension.
 
flatiter
 
Examples
--------
>>> x = np.arange(1, 7).reshape(2, 3)
>>> x
array([[1, 2, 3],
       [4, 5, 6]])
>>> x.flat[3]
4
>>> x.T
array([[1, 4],
       [2, 5],
       [3, 6]])
>>> x.T.flat[3]
5
>>> type(x.flat)
<type 'numpy.flatiter'>
 
An assignment example:
 
>>> x.flat = 3; x
array([[3, 3, 3],
       [3, 3, 3]])
>>> x.flat[[1,4]] = 1; x
array([[3, 1, 3],
       [3, 1, 3]])
imag
The imaginary part of the array.
 
Examples
--------
>>> x = np.sqrt([1+0j, 0+1j])
>>> x.imag
array([ 0.        ,  0.70710678])
>>> x.imag.dtype
dtype('float64')
itemsize
Length of one array element in bytes.
 
Examples
--------
>>> x = np.array([1,2,3], dtype=np.float64)
>>> x.itemsize
8
>>> x = np.array([1,2,3], dtype=np.complex128)
>>> x.itemsize
16
nbytes
Total bytes consumed by the elements of the array.
 
Notes
-----
Does not include memory consumed by non-element attributes of the
array object.
 
Examples
--------
>>> x = np.zeros((3,5,2), dtype=np.complex128)
>>> x.nbytes
480
>>> np.prod(x.shape) * x.itemsize
480
ndim
Number of array dimensions.
 
Examples
--------
>>> x = np.array([1, 2, 3])
>>> x.ndim
1
>>> y = np.zeros((2, 3, 4))
>>> y.ndim
3
real
The real part of the array.
 
Examples
--------
>>> x = np.sqrt([1+0j, 0+1j])
>>> x.real
array([ 1.        ,  0.70710678])
>>> x.real.dtype
dtype('float64')
 
See Also
--------
numpy.real : equivalent function
shape
Tuple of array dimensions.
 
Notes
-----
May be used to "reshape" the array, as long as this would not
require a change in the total number of elements
 
Examples
--------
>>> x = np.array([1, 2, 3, 4])
>>> x.shape
(4,)
>>> y = np.zeros((2, 3, 4))
>>> y.shape
(2, 3, 4)
>>> y.shape = (3, 8)
>>> y
array([[ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.],
       [ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.],
       [ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.]])
>>> y.shape = (3, 6)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: total size of new array must be unchanged
size
Number of elements in the array.
 
Equivalent to ``np.prod(a.shape)``, i.e., the product of the array's
dimensions.
 
Examples
--------
>>> x = np.zeros((3, 5, 2), dtype=np.complex128)
>>> x.size
30
>>> np.prod(x.shape)
30
strides
Tuple of bytes to step in each dimension when traversing an array.
 
The byte offset of element ``(i[0], i[1], ..., i[n])`` in an array `a`
is::
 
    offset = sum(np.array(i) * a.strides)
 
A more detailed explanation of strides can be found in the
"ndarray.rst" file in the NumPy reference guide.
 
Notes
-----
Imagine an array of 32-bit integers (each 4 bytes)::
 
  x = np.array([[0, 1, 2, 3, 4],
                [5, 6, 7, 8, 9]], dtype=np.int32)
 
This array is stored in memory as 40 bytes, one after the other
(known as a contiguous block of memory).  The strides of an array tell
us how many bytes we have to skip in memory to move to the next position
along a certain axis.  For example, we have to skip 4 bytes (1 value) to
move to the next column, but 20 bytes (5 values) to get to the same
position in the next row.  As such, the strides for the array `x` will be
``(20, 4)``.
 
See Also
--------
numpy.lib.stride_tricks.as_strided
 
Examples
--------
>>> y = np.reshape(np.arange(2*3*4), (2,3,4))
>>> y
array([[[ 0,  1,  2,  3],
        [ 4,  5,  6,  7],
        [ 8,  9, 10, 11]],
       [[12, 13, 14, 15],
        [16, 17, 18, 19],
        [20, 21, 22, 23]]])
>>> y.strides
(48, 16, 4)
>>> y[1,1,1]
17
>>> offset=sum(y.strides * np.array((1,1,1)))
>>> offset/y.itemsize
17
 
>>> x = np.reshape(np.arange(5*6*7*8), (5,6,7,8)).transpose(2,3,1,0)
>>> x.strides
(32, 4, 224, 1344)
>>> i = np.array([3,5,2,2])
>>> offset = sum(i * x.strides)
>>> x[3,5,2,2]
813
>>> offset / x.itemsize
813

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

Methods defined here:
__complex__(...)
__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>
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
__format__(...)
NumPy array scalar formatter
__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(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
any(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
argmax(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
argmin(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
argsort(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
astype(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
byteswap(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class so as to
provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
choose(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
clip(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
compress(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
conj(...)
conjugate(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
copy(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
cumprod(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
cumsum(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
diagonal(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
dump(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
dumps(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
fill(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
flatten(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
getfield(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
item(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
itemset(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
max(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
mean(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
min(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
newbyteorder(...)
newbyteorder(new_order='S')
 
Return a new `dtype` with a different byte order.
 
Changes are also made in all fields and sub-arrays of the data type.
 
The `new_order` code can be any from the following:
 
* {'<', '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 : str, optional
    Byte order to force; a value from the byte order specifications
    above.  The default value ('S') results in swapping the current
    byte order. The code does a case-insensitive check on the first
    letter of `new_order` for the alternatives above.  For example,
    any of 'B' or 'b' or 'biggish' are valid to specify big-endian.
 
 
Returns
-------
new_dtype : dtype
    New `dtypeobject with the given change to the byte order.
nonzero(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
prod(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
ptp(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
put(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
ravel(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
repeat(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
reshape(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
resize(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
round(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
searchsorted(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
setfield(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
setflags(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class so as to
provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
sort(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
squeeze(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
std(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
sum(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
swapaxes(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
take(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
tofile(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
tolist(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
tostring(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
trace(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
transpose(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
var(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
view(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.

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

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

Methods defined here:
__complex__(...)
__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>
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
__format__(...)
NumPy array scalar formatter
__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(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
any(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
argmax(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
argmin(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
argsort(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
astype(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
byteswap(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class so as to
provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
choose(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
clip(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
compress(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
conj(...)
conjugate(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
copy(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
cumprod(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
cumsum(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
diagonal(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
dump(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
dumps(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
fill(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
flatten(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
getfield(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
item(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
itemset(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
max(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
mean(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
min(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
newbyteorder(...)
newbyteorder(new_order='S')
 
Return a new `dtype` with a different byte order.
 
Changes are also made in all fields and sub-arrays of the data type.
 
The `new_order` code can be any from the following:
 
* {'<', '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 : str, optional
    Byte order to force; a value from the byte order specifications
    above.  The default value ('S') results in swapping the current
    byte order. The code does a case-insensitive check on the first
    letter of `new_order` for the alternatives above.  For example,
    any of 'B' or 'b' or 'biggish' are valid to specify big-endian.
 
 
Returns
-------
new_dtype : dtype
    New `dtypeobject with the given change to the byte order.
nonzero(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
prod(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
ptp(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
put(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
ravel(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
repeat(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
reshape(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
resize(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
round(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
searchsorted(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
setfield(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
setflags(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class so as to
provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
sort(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
squeeze(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
std(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
sum(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
swapaxes(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
take(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
tofile(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
tolist(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
tostring(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
trace(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
transpose(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
var(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
view(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.

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

 
class complex128(complexfloating, __builtin__.complex)
    Composed of two 64 bit floats
 
 
Method resolution order:
complex128
complexfloating
inexact
number
generic
__builtin__.complex
__builtin__.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>
T.__new__(S, ...) -> a new object with type S, a subtype of T

Methods inherited from generic:
__abs__(...)
x.__abs__() <==> abs(x)
__add__(...)
x.__add__(y) <==> x+y
__and__(...)
x.__and__(y) <==> x&y
__array__(...)
sc.__array__(|type) return 0-dim array
__array_wrap__(...)
sc.__array_wrap__(obj) return scalar from array
__copy__(...)
__deepcopy__(...)
__div__(...)
x.__div__(y) <==> x/y
__divmod__(...)
x.__divmod__(y) <==> divmod(x, y)
__float__(...)
x.__float__() <==> float(x)
__floordiv__(...)
x.__floordiv__(y) <==> x//y
__format__(...)
NumPy array scalar formatter
__getitem__(...)
x.__getitem__(y) <==> x[y]
__hex__(...)
x.__hex__() <==> hex(x)
__int__(...)
x.__int__() <==> int(x)
__invert__(...)
x.__invert__() <==> ~x
__long__(...)
x.__long__() <==> long(x)
__lshift__(...)
x.__lshift__(y) <==> x<<y
__mod__(...)
x.__mod__(y) <==> x%y
__mul__(...)
x.__mul__(y) <==> x*y
__neg__(...)
x.__neg__() <==> -x
__nonzero__(...)
x.__nonzero__() <==> x != 0
__oct__(...)
x.__oct__() <==> oct(x)
__or__(...)
x.__or__(y) <==> x|y
__pos__(...)
x.__pos__() <==> +x
__pow__(...)
x.__pow__(y[, z]) <==> pow(x, y[, z])
__radd__(...)
x.__radd__(y) <==> y+x
__rand__(...)
x.__rand__(y) <==> y&x
__rdiv__(...)
x.__rdiv__(y) <==> y/x
__rdivmod__(...)
x.__rdivmod__(y) <==> divmod(y, x)
__reduce__(...)
__rfloordiv__(...)
x.__rfloordiv__(y) <==> y//x
__rlshift__(...)
x.__rlshift__(y) <==> y<<x
__rmod__(...)
x.__rmod__(y) <==> y%x
__rmul__(...)
x.__rmul__(y) <==> y*x
__ror__(...)
x.__ror__(y) <==> y|x
__rpow__(...)
y.__rpow__(x[, z]) <==> pow(x, y[, z])
__rrshift__(...)
x.__rrshift__(y) <==> y>>x
__rshift__(...)
x.__rshift__(y) <==> x>>y
__rsub__(...)
x.__rsub__(y) <==> y-x
__rtruediv__(...)
x.__rtruediv__(y) <==> y/x
__rxor__(...)
x.__rxor__(y) <==> y^x
__setstate__(...)
__sub__(...)
x.__sub__(y) <==> x-y
__truediv__(...)
x.__truediv__(y) <==> x/y
__xor__(...)
x.__xor__(y) <==> x^y
all(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
any(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
argmax(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
argmin(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
argsort(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
astype(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
byteswap(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class so as to
provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
choose(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
clip(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
compress(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
conj(...)
conjugate(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
copy(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
cumprod(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
cumsum(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
diagonal(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
dump(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
dumps(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
fill(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
flatten(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
getfield(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
item(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
itemset(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
max(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
mean(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
min(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
newbyteorder(...)
newbyteorder(new_order='S')
 
Return a new `dtype` with a different byte order.
 
Changes are also made in all fields and sub-arrays of the data type.
 
The `new_order` code can be any from the following:
 
* {'<', '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 : str, optional
    Byte order to force; a value from the byte order specifications
    above.  The default value ('S') results in swapping the current
    byte order. The code does a case-insensitive check on the first
    letter of `new_order` for the alternatives above.  For example,
    any of 'B' or 'b' or 'biggish' are valid to specify big-endian.
 
 
Returns
-------
new_dtype : dtype
    New `dtypeobject with the given change to the byte order.
nonzero(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
prod(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
ptp(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
put(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
ravel(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
repeat(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
reshape(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
resize(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
round(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
searchsorted(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
setfield(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
setflags(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class so as to
provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
sort(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
squeeze(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
std(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
sum(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
swapaxes(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
take(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
tofile(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
tolist(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
tostring(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
trace(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
transpose(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
var(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
view(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.

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

Methods inherited from __builtin__.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
__builtin__.object

Methods defined here:
__complex__(...)
__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>
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
__format__(...)
NumPy array scalar formatter
__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(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
any(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
argmax(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
argmin(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
argsort(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
astype(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
byteswap(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class so as to
provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
choose(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
clip(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
compress(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
conj(...)
conjugate(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
copy(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
cumprod(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
cumsum(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
diagonal(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
dump(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
dumps(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
fill(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
flatten(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
getfield(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
item(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
itemset(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
max(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
mean(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
min(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
newbyteorder(...)
newbyteorder(new_order='S')
 
Return a new `dtype` with a different byte order.
 
Changes are also made in all fields and sub-arrays of the data type.
 
The `new_order` code can be any from the following:
 
* {'<', '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 : str, optional
    Byte order to force; a value from the byte order specifications
    above.  The default value ('S') results in swapping the current
    byte order. The code does a case-insensitive check on the first
    letter of `new_order` for the alternatives above.  For example,
    any of 'B' or 'b' or 'biggish' are valid to specify big-endian.
 
 
Returns
-------
new_dtype : dtype
    New `dtypeobject with the given change to the byte order.
nonzero(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
prod(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
ptp(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
put(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
ravel(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
repeat(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
reshape(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
resize(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
round(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
searchsorted(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
setfield(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
setflags(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class so as to
provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
sort(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
squeeze(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
std(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
sum(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
swapaxes(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
take(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
tofile(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
tolist(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
tostring(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
trace(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
transpose(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
var(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
view(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.

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

 
class complex64(complexfloating)
    Composed of two 32 bit floats
 
 
Method resolution order:
complex64
complexfloating
inexact
number
generic
__builtin__.object

Methods defined here:
__complex__(...)
__eq__(...)
x.__eq__(y) <==> x==y
__ge__(...)
x.__ge__(y) <==> x>=y
__gt__(...)
x.__gt__(y) <==> x>y
__hash__(...)
x.__hash__() <==> hash(x)
__le__(...)
x.__le__(y) <==> x<=y
__lt__(...)
x.__lt__(y) <==> x<y
__ne__(...)
x.__ne__(y) <==> x!=y
__repr__(...)
x.__repr__() <==> repr(x)
__str__(...)
x.__str__() <==> str(x)

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

Methods inherited from generic:
__abs__(...)
x.__abs__() <==> abs(x)
__add__(...)
x.__add__(y) <==> x+y
__and__(...)
x.__and__(y) <==> x&y
__array__(...)
sc.__array__(|type) return 0-dim array
__array_wrap__(...)
sc.__array_wrap__(obj) return scalar from array
__copy__(...)
__deepcopy__(...)
__div__(...)
x.__div__(y) <==> x/y
__divmod__(...)
x.__divmod__(y) <==> divmod(x, y)
__float__(...)
x.__float__() <==> float(x)
__floordiv__(...)
x.__floordiv__(y) <==> x//y
__format__(...)
NumPy array scalar formatter
__getitem__(...)
x.__getitem__(y) <==> x[y]
__hex__(...)
x.__hex__() <==> hex(x)
__int__(...)
x.__int__() <==> int(x)
__invert__(...)
x.__invert__() <==> ~x
__long__(...)
x.__long__() <==> long(x)
__lshift__(...)
x.__lshift__(y) <==> x<<y
__mod__(...)
x.__mod__(y) <==> x%y
__mul__(...)
x.__mul__(y) <==> x*y
__neg__(...)
x.__neg__() <==> -x
__nonzero__(...)
x.__nonzero__() <==> x != 0
__oct__(...)
x.__oct__() <==> oct(x)
__or__(...)
x.__or__(y) <==> x|y
__pos__(...)
x.__pos__() <==> +x
__pow__(...)
x.__pow__(y[, z]) <==> pow(x, y[, z])
__radd__(...)
x.__radd__(y) <==> y+x
__rand__(...)
x.__rand__(y) <==> y&x
__rdiv__(...)
x.__rdiv__(y) <==> y/x
__rdivmod__(...)
x.__rdivmod__(y) <==> divmod(y, x)
__reduce__(...)
__rfloordiv__(...)
x.__rfloordiv__(y) <==> y//x
__rlshift__(...)
x.__rlshift__(y) <==> y<<x
__rmod__(...)
x.__rmod__(y) <==> y%x
__rmul__(...)
x.__rmul__(y) <==> y*x
__ror__(...)
x.__ror__(y) <==> y|x
__rpow__(...)
y.__rpow__(x[, z]) <==> pow(x, y[, z])
__rrshift__(...)
x.__rrshift__(y) <==> y>>x
__rshift__(...)
x.__rshift__(y) <==> x>>y
__rsub__(...)
x.__rsub__(y) <==> y-x
__rtruediv__(...)
x.__rtruediv__(y) <==> y/x
__rxor__(...)
x.__rxor__(y) <==> y^x
__setstate__(...)
__sub__(...)
x.__sub__(y) <==> x-y
__truediv__(...)
x.__truediv__(y) <==> x/y
__xor__(...)
x.__xor__(y) <==> x^y
all(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
any(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
argmax(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
argmin(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
argsort(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
astype(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
byteswap(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class so as to
provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
choose(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
clip(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
compress(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
conj(...)
conjugate(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
copy(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
cumprod(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
cumsum(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
diagonal(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
dump(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
dumps(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
fill(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
flatten(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
getfield(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
item(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
itemset(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
max(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
mean(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
min(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
newbyteorder(...)
newbyteorder(new_order='S')
 
Return a new `dtype` with a different byte order.
 
Changes are also made in all fields and sub-arrays of the data type.
 
The `new_order` code can be any from the following:
 
* {'<', '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 : str, optional
    Byte order to force; a value from the byte order specifications
    above.  The default value ('S') results in swapping the current
    byte order. The code does a case-insensitive check on the first
    letter of `new_order` for the alternatives above.  For example,
    any of 'B' or 'b' or 'biggish' are valid to specify big-endian.
 
 
Returns
-------
new_dtype : dtype
    New `dtypeobject with the given change to the byte order.
nonzero(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
prod(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
ptp(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
put(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
ravel(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
repeat(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
reshape(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
resize(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
round(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
searchsorted(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
setfield(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
setflags(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class so as to
provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
sort(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
squeeze(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
std(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
sum(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
swapaxes(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
take(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
tofile(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
tolist(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
tostring(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
trace(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
transpose(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
var(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
view(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.

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

 
complex_ = class complex128(complexfloating, __builtin__.complex)
    Composed of two 64 bit floats
 
 
Method resolution order:
complex128
complexfloating
inexact
number
generic
__builtin__.complex
__builtin__.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>
T.__new__(S, ...) -> a new object with type S, a subtype of T

Methods inherited from generic:
__abs__(...)
x.__abs__() <==> abs(x)
__add__(...)
x.__add__(y) <==> x+y
__and__(...)
x.__and__(y) <==> x&y
__array__(...)
sc.__array__(|type) return 0-dim array
__array_wrap__(...)
sc.__array_wrap__(obj) return scalar from array
__copy__(...)
__deepcopy__(...)
__div__(...)
x.__div__(y) <==> x/y
__divmod__(...)
x.__divmod__(y) <==> divmod(x, y)
__float__(...)
x.__float__() <==> float(x)
__floordiv__(...)
x.__floordiv__(y) <==> x//y
__format__(...)
NumPy array scalar formatter
__getitem__(...)
x.__getitem__(y) <==> x[y]
__hex__(...)
x.__hex__() <==> hex(x)
__int__(...)
x.__int__() <==> int(x)
__invert__(...)
x.__invert__() <==> ~x
__long__(...)
x.__long__() <==> long(x)
__lshift__(...)
x.__lshift__(y) <==> x<<y
__mod__(...)
x.__mod__(y) <==> x%y
__mul__(...)
x.__mul__(y) <==> x*y
__neg__(...)
x.__neg__() <==> -x
__nonzero__(...)
x.__nonzero__() <==> x != 0
__oct__(...)
x.__oct__() <==> oct(x)
__or__(...)
x.__or__(y) <==> x|y
__pos__(...)
x.__pos__() <==> +x
__pow__(...)
x.__pow__(y[, z]) <==> pow(x, y[, z])
__radd__(...)
x.__radd__(y) <==> y+x
__rand__(...)
x.__rand__(y) <==> y&x
__rdiv__(...)
x.__rdiv__(y) <==> y/x
__rdivmod__(...)
x.__rdivmod__(y) <==> divmod(y, x)
__reduce__(...)
__rfloordiv__(...)
x.__rfloordiv__(y) <==> y//x
__rlshift__(...)
x.__rlshift__(y) <==> y<<x
__rmod__(...)
x.__rmod__(y) <==> y%x
__rmul__(...)
x.__rmul__(y) <==> y*x
__ror__(...)
x.__ror__(y) <==> y|x
__rpow__(...)
y.__rpow__(x[, z]) <==> pow(x, y[, z])
__rrshift__(...)
x.__rrshift__(y) <==> y>>x
__rshift__(...)
x.__rshift__(y) <==> x>>y
__rsub__(...)
x.__rsub__(y) <==> y-x
__rtruediv__(...)
x.__rtruediv__(y) <==> y/x
__rxor__(...)
x.__rxor__(y) <==> y^x
__setstate__(...)
__sub__(...)
x.__sub__(y) <==> x-y
__truediv__(...)
x.__truediv__(y) <==> x/y
__xor__(...)
x.__xor__(y) <==> x^y
all(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
any(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
argmax(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
argmin(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
argsort(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
astype(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
byteswap(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class so as to
provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
choose(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
clip(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
compress(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
conj(...)
conjugate(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
copy(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
cumprod(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
cumsum(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
diagonal(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
dump(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
dumps(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
fill(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
flatten(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
getfield(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
item(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
itemset(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
max(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
mean(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
min(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
newbyteorder(...)
newbyteorder(new_order='S')
 
Return a new `dtype` with a different byte order.
 
Changes are also made in all fields and sub-arrays of the data type.
 
The `new_order` code can be any from the following:
 
* {'<', '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 : str, optional
    Byte order to force; a value from the byte order specifications
    above.  The default value ('S') results in swapping the current
    byte order. The code does a case-insensitive check on the first
    letter of `new_order` for the alternatives above.  For example,
    any of 'B' or 'b' or 'biggish' are valid to specify big-endian.
 
 
Returns
-------
new_dtype : dtype
    New `dtypeobject with the given change to the byte order.
nonzero(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
prod(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
ptp(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
put(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
ravel(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
repeat(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
reshape(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
resize(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
round(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
searchsorted(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
setfield(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
setflags(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class so as to
provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
sort(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
squeeze(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
std(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
sum(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
swapaxes(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
take(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
tofile(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
tolist(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
tostring(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
trace(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
transpose(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
var(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
view(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.

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

Methods inherited from __builtin__.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
__builtin__.object

Methods inherited from generic:
__abs__(...)
x.__abs__() <==> abs(x)
__add__(...)
x.__add__(y) <==> x+y
__and__(...)
x.__and__(y) <==> x&y
__array__(...)
sc.__array__(|type) return 0-dim array
__array_wrap__(...)
sc.__array_wrap__(obj) return scalar from array
__copy__(...)
__deepcopy__(...)
__div__(...)
x.__div__(y) <==> x/y
__divmod__(...)
x.__divmod__(y) <==> divmod(x, y)
__eq__(...)
x.__eq__(y) <==> x==y
__float__(...)
x.__float__() <==> float(x)
__floordiv__(...)
x.__floordiv__(y) <==> x//y
__format__(...)
NumPy array scalar formatter
__ge__(...)
x.__ge__(y) <==> x>=y
__getitem__(...)
x.__getitem__(y) <==> x[y]
__gt__(...)
x.__gt__(y) <==> x>y
__hex__(...)
x.__hex__() <==> hex(x)
__int__(...)
x.__int__() <==> int(x)
__invert__(...)
x.__invert__() <==> ~x
__le__(...)
x.__le__(y) <==> x<=y
__long__(...)
x.__long__() <==> long(x)
__lshift__(...)
x.__lshift__(y) <==> x<<y
__lt__(...)
x.__lt__(y) <==> x<y
__mod__(...)
x.__mod__(y) <==> x%y
__mul__(...)
x.__mul__(y) <==> x*y
__ne__(...)
x.__ne__(y) <==> x!=y
__neg__(...)
x.__neg__() <==> -x
__nonzero__(...)
x.__nonzero__() <==> x != 0
__oct__(...)
x.__oct__() <==> oct(x)
__or__(...)
x.__or__(y) <==> x|y
__pos__(...)
x.__pos__() <==> +x
__pow__(...)
x.__pow__(y[, z]) <==> pow(x, y[, z])
__radd__(...)
x.__radd__(y) <==> y+x
__rand__(...)
x.__rand__(y) <==> y&x
__rdiv__(...)
x.__rdiv__(y) <==> y/x
__rdivmod__(...)
x.__rdivmod__(y) <==> divmod(y, x)
__reduce__(...)
__repr__(...)
x.__repr__() <==> repr(x)
__rfloordiv__(...)
x.__rfloordiv__(y) <==> y//x
__rlshift__(...)
x.__rlshift__(y) <==> y<<x
__rmod__(...)
x.__rmod__(y) <==> y%x
__rmul__(...)
x.__rmul__(y) <==> y*x
__ror__(...)
x.__ror__(y) <==> y|x
__rpow__(...)
y.__rpow__(x[, z]) <==> pow(x, y[, z])
__rrshift__(...)
x.__rrshift__(y) <==> y>>x
__rshift__(...)
x.__rshift__(y) <==> x>>y
__rsub__(...)
x.__rsub__(y) <==> y-x
__rtruediv__(...)
x.__rtruediv__(y) <==> y/x
__rxor__(...)
x.__rxor__(y) <==> y^x
__setstate__(...)
__str__(...)
x.__str__() <==> str(x)
__sub__(...)
x.__sub__(y) <==> x-y
__truediv__(...)
x.__truediv__(y) <==> x/y
__xor__(...)
x.__xor__(y) <==> x^y
all(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
any(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
argmax(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
argmin(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
argsort(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
astype(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
byteswap(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class so as to
provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
choose(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
clip(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
compress(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
conj(...)
conjugate(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
copy(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
cumprod(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
cumsum(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
diagonal(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
dump(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
dumps(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
fill(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
flatten(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
getfield(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
item(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
itemset(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
max(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
mean(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
min(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
newbyteorder(...)
newbyteorder(new_order='S')
 
Return a new `dtype` with a different byte order.
 
Changes are also made in all fields and sub-arrays of the data type.
 
The `new_order` code can be any from the following:
 
* {'<', '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 : str, optional
    Byte order to force; a value from the byte order specifications
    above.  The default value ('S') results in swapping the current
    byte order. The code does a case-insensitive check on the first
    letter of `new_order` for the alternatives above.  For example,
    any of 'B' or 'b' or 'biggish' are valid to specify big-endian.
 
 
Returns
-------
new_dtype : dtype
    New `dtypeobject with the given change to the byte order.
nonzero(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
prod(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
ptp(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
put(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
ravel(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
repeat(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
reshape(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
resize(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
round(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
searchsorted(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
setfield(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
setflags(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class so as to
provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
sort(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
squeeze(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
std(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
sum(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
swapaxes(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
take(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
tofile(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
tolist(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
tostring(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
trace(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
transpose(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
var(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
view(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.

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

 
csingle = class complex64(complexfloating)
    Composed of two 32 bit floats
 
 
Method resolution order:
complex64
complexfloating
inexact
number
generic
__builtin__.object

Methods defined here:
__complex__(...)
__eq__(...)
x.__eq__(y) <==> x==y
__ge__(...)
x.__ge__(y) <==> x>=y
__gt__(...)
x.__gt__(y) <==> x>y
__hash__(...)
x.__hash__() <==> hash(x)
__le__(...)
x.__le__(y) <==> x<=y
__lt__(...)
x.__lt__(y) <==> x<y
__ne__(...)
x.__ne__(y) <==> x!=y
__repr__(...)
x.__repr__() <==> repr(x)
__str__(...)
x.__str__() <==> str(x)

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

Methods inherited from generic:
__abs__(...)
x.__abs__() <==> abs(x)
__add__(...)
x.__add__(y) <==> x+y
__and__(...)
x.__and__(y) <==> x&y
__array__(...)
sc.__array__(|type) return 0-dim array
__array_wrap__(...)
sc.__array_wrap__(obj) return scalar from array
__copy__(...)
__deepcopy__(...)
__div__(...)
x.__div__(y) <==> x/y
__divmod__(...)
x.__divmod__(y) <==> divmod(x, y)
__float__(...)
x.__float__() <==> float(x)
__floordiv__(...)
x.__floordiv__(y) <==> x//y
__format__(...)
NumPy array scalar formatter
__getitem__(...)
x.__getitem__(y) <==> x[y]
__hex__(...)
x.__hex__() <==> hex(x)
__int__(...)
x.__int__() <==> int(x)
__invert__(...)
x.__invert__() <==> ~x
__long__(...)
x.__long__() <==> long(x)
__lshift__(...)
x.__lshift__(y) <==> x<<y
__mod__(...)
x.__mod__(y) <==> x%y
__mul__(...)
x.__mul__(y) <==> x*y
__neg__(...)
x.__neg__() <==> -x
__nonzero__(...)
x.__nonzero__() <==> x != 0
__oct__(...)
x.__oct__() <==> oct(x)
__or__(...)
x.__or__(y) <==> x|y
__pos__(...)
x.__pos__() <==> +x
__pow__(...)
x.__pow__(y[, z]) <==> pow(x, y[, z])
__radd__(...)
x.__radd__(y) <==> y+x
__rand__(...)
x.__rand__(y) <==> y&x
__rdiv__(...)
x.__rdiv__(y) <==> y/x
__rdivmod__(...)
x.__rdivmod__(y) <==> divmod(y, x)
__reduce__(...)
__rfloordiv__(...)
x.__rfloordiv__(y) <==> y//x
__rlshift__(...)
x.__rlshift__(y) <==> y<<x
__rmod__(...)
x.__rmod__(y) <==> y%x
__rmul__(...)
x.__rmul__(y) <==> y*x
__ror__(...)
x.__ror__(y) <==> y|x
__rpow__(...)
y.__rpow__(x[, z]) <==> pow(x, y[, z])
__rrshift__(...)
x.__rrshift__(y) <==> y>>x
__rshift__(...)
x.__rshift__(y) <==> x>>y
__rsub__(...)
x.__rsub__(y) <==> y-x
__rtruediv__(...)
x.__rtruediv__(y) <==> y/x
__rxor__(...)
x.__rxor__(y) <==> y^x
__setstate__(...)
__sub__(...)
x.__sub__(y) <==> x-y
__truediv__(...)
x.__truediv__(y) <==> x/y
__xor__(...)
x.__xor__(y) <==> x^y
all(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
any(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
argmax(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
argmin(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
argsort(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
astype(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
byteswap(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class so as to
provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
choose(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
clip(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
compress(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
conj(...)
conjugate(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
copy(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
cumprod(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
cumsum(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
diagonal(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
dump(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
dumps(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
fill(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
flatten(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
getfield(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
item(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
itemset(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
max(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
mean(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
min(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
newbyteorder(...)
newbyteorder(new_order='S')
 
Return a new `dtype` with a different byte order.
 
Changes are also made in all fields and sub-arrays of the data type.
 
The `new_order` code can be any from the following:
 
* {'<', '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 : str, optional
    Byte order to force; a value from the byte order specifications
    above.  The default value ('S') results in swapping the current
    byte order. The code does a case-insensitive check on the first
    letter of `new_order` for the alternatives above.  For example,
    any of 'B' or 'b' or 'biggish' are valid to specify big-endian.
 
 
Returns
-------
new_dtype : dtype
    New `dtypeobject with the given change to the byte order.
nonzero(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
prod(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
ptp(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
put(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
ravel(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
repeat(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
reshape(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
resize(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
round(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
searchsorted(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
setfield(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
setflags(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class so as to
provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
sort(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
squeeze(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
std(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
sum(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
swapaxes(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
take(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
tofile(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
tolist(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
tostring(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
trace(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
transpose(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
var(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
view(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.

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

 
class datetime64(generic)
    
Method resolution order:
datetime64
generic
__builtin__.object

Methods defined here:
__eq__(...)
x.__eq__(y) <==> x==y
__ge__(...)
x.__ge__(y) <==> x>=y
__gt__(...)
x.__gt__(y) <==> x>y
__hash__(...)
x.__hash__() <==> hash(x)
__le__(...)
x.__le__(y) <==> x<=y
__lt__(...)
x.__lt__(y) <==> x<y
__ne__(...)
x.__ne__(y) <==> x!=y
__repr__(...)
x.__repr__() <==> repr(x)
__str__(...)
x.__str__() <==> str(x)

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

Methods inherited from generic:
__abs__(...)
x.__abs__() <==> abs(x)
__add__(...)
x.__add__(y) <==> x+y
__and__(...)
x.__and__(y) <==> x&y
__array__(...)
sc.__array__(|type) return 0-dim array
__array_wrap__(...)
sc.__array_wrap__(obj) return scalar from array
__copy__(...)
__deepcopy__(...)
__div__(...)
x.__div__(y) <==> x/y
__divmod__(...)
x.__divmod__(y) <==> divmod(x, y)
__float__(...)
x.__float__() <==> float(x)
__floordiv__(...)
x.__floordiv__(y) <==> x//y
__format__(...)
NumPy array scalar formatter
__getitem__(...)
x.__getitem__(y) <==> x[y]
__hex__(...)
x.__hex__() <==> hex(x)
__int__(...)
x.__int__() <==> int(x)
__invert__(...)
x.__invert__() <==> ~x
__long__(...)
x.__long__() <==> long(x)
__lshift__(...)
x.__lshift__(y) <==> x<<y
__mod__(...)
x.__mod__(y) <==> x%y
__mul__(...)
x.__mul__(y) <==> x*y
__neg__(...)
x.__neg__() <==> -x
__nonzero__(...)
x.__nonzero__() <==> x != 0
__oct__(...)
x.__oct__() <==> oct(x)
__or__(...)
x.__or__(y) <==> x|y
__pos__(...)
x.__pos__() <==> +x
__pow__(...)
x.__pow__(y[, z]) <==> pow(x, y[, z])
__radd__(...)
x.__radd__(y) <==> y+x
__rand__(...)
x.__rand__(y) <==> y&x
__rdiv__(...)
x.__rdiv__(y) <==> y/x
__rdivmod__(...)
x.__rdivmod__(y) <==> divmod(y, x)
__reduce__(...)
__rfloordiv__(...)
x.__rfloordiv__(y) <==> y//x
__rlshift__(...)
x.__rlshift__(y) <==> y<<x
__rmod__(...)
x.__rmod__(y) <==> y%x
__rmul__(...)
x.__rmul__(y) <==> y*x
__ror__(...)
x.__ror__(y) <==> y|x
__rpow__(...)
y.__rpow__(x[, z]) <==> pow(x, y[, z])
__rrshift__(...)
x.__rrshift__(y) <==> y>>x
__rshift__(...)
x.__rshift__(y) <==> x>>y
__rsub__(...)
x.__rsub__(y) <==> y-x
__rtruediv__(...)
x.__rtruediv__(y) <==> y/x
__rxor__(...)
x.__rxor__(y) <==> y^x
__setstate__(...)
__sub__(...)
x.__sub__(y) <==> x-y
__truediv__(...)
x.__truediv__(y) <==> x/y
__xor__(...)
x.__xor__(y) <==> x^y
all(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
any(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
argmax(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
argmin(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
argsort(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
astype(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
byteswap(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class so as to
provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
choose(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
clip(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
compress(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
conj(...)
conjugate(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
copy(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
cumprod(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
cumsum(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
diagonal(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
dump(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
dumps(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
fill(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
flatten(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
getfield(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
item(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
itemset(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
max(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
mean(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
min(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
newbyteorder(...)
newbyteorder(new_order='S')
 
Return a new `dtype` with a different byte order.
 
Changes are also made in all fields and sub-arrays of the data type.
 
The `new_order` code can be any from the following:
 
* {'<', '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 : str, optional
    Byte order to force; a value from the byte order specifications
    above.  The default value ('S') results in swapping the current
    byte order. The code does a case-insensitive check on the first
    letter of `new_order` for the alternatives above.  For example,
    any of 'B' or 'b' or 'biggish' are valid to specify big-endian.
 
 
Returns
-------
new_dtype : dtype
    New `dtypeobject with the given change to the byte order.
nonzero(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
prod(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
ptp(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
put(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
ravel(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
repeat(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
reshape(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
resize(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
round(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
searchsorted(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
setfield(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
setflags(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class so as to
provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
sort(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
squeeze(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
std(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
sum(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
swapaxes(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
take(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
tofile(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
tolist(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
tostring(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
trace(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
transpose(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
var(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
view(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.

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

 
double = class float64(floating, __builtin__.float)
    64-bit floating-point number. Character code 'd'. Python float compatible.
 
 
Method resolution order:
float64
floating
inexact
number
generic
__builtin__.float
__builtin__.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>
T.__new__(S, ...) -> a new object with type S, a subtype of T

Methods inherited from generic:
__abs__(...)
x.__abs__() <==> abs(x)
__add__(...)
x.__add__(y) <==> x+y
__and__(...)
x.__and__(y) <==> x&y
__array__(...)
sc.__array__(|type) return 0-dim array
__array_wrap__(...)
sc.__array_wrap__(obj) return scalar from array
__copy__(...)
__deepcopy__(...)
__div__(...)
x.__div__(y) <==> x/y
__divmod__(...)
x.__divmod__(y) <==> divmod(x, y)
__float__(...)
x.__float__() <==> float(x)
__floordiv__(...)
x.__floordiv__(y) <==> x//y
__format__(...)
NumPy array scalar formatter
__getitem__(...)
x.__getitem__(y) <==> x[y]
__hex__(...)
x.__hex__() <==> hex(x)
__int__(...)
x.__int__() <==> int(x)
__invert__(...)
x.__invert__() <==> ~x
__long__(...)
x.__long__() <==> long(x)
__lshift__(...)
x.__lshift__(y) <==> x<<y
__mod__(...)
x.__mod__(y) <==> x%y
__mul__(...)
x.__mul__(y) <==> x*y
__neg__(...)
x.__neg__() <==> -x
__nonzero__(...)
x.__nonzero__() <==> x != 0
__oct__(...)
x.__oct__() <==> oct(x)
__or__(...)
x.__or__(y) <==> x|y
__pos__(...)
x.__pos__() <==> +x
__pow__(...)
x.__pow__(y[, z]) <==> pow(x, y[, z])
__radd__(...)
x.__radd__(y) <==> y+x
__rand__(...)
x.__rand__(y) <==> y&x
__rdiv__(...)
x.__rdiv__(y) <==> y/x
__rdivmod__(...)
x.__rdivmod__(y) <==> divmod(y, x)
__reduce__(...)
__rfloordiv__(...)
x.__rfloordiv__(y) <==> y//x
__rlshift__(...)
x.__rlshift__(y) <==> y<<x
__rmod__(...)
x.__rmod__(y) <==> y%x
__rmul__(...)
x.__rmul__(y) <==> y*x
__ror__(...)
x.__ror__(y) <==> y|x
__rpow__(...)
y.__rpow__(x[, z]) <==> pow(x, y[, z])
__rrshift__(...)
x.__rrshift__(y) <==> y>>x
__rshift__(...)
x.__rshift__(y) <==> x>>y
__rsub__(...)
x.__rsub__(y) <==> y-x
__rtruediv__(...)
x.__rtruediv__(y) <==> y/x
__rxor__(...)
x.__rxor__(y) <==> y^x
__setstate__(...)
__sub__(...)
x.__sub__(y) <==> x-y
__truediv__(...)
x.__truediv__(y) <==> x/y
__xor__(...)
x.__xor__(y) <==> x^y
all(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
any(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
argmax(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
argmin(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
argsort(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
astype(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
byteswap(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class so as to
provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
choose(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
clip(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
compress(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
conj(...)
conjugate(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
copy(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
cumprod(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
cumsum(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
diagonal(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
dump(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
dumps(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
fill(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
flatten(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
getfield(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
item(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
itemset(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
max(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
mean(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
min(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
newbyteorder(...)
newbyteorder(new_order='S')
 
Return a new `dtype` with a different byte order.
 
Changes are also made in all fields and sub-arrays of the data type.
 
The `new_order` code can be any from the following:
 
* {'<', '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 : str, optional
    Byte order to force; a value from the byte order specifications
    above.  The default value ('S') results in swapping the current
    byte order. The code does a case-insensitive check on the first
    letter of `new_order` for the alternatives above.  For example,
    any of 'B' or 'b' or 'biggish' are valid to specify big-endian.
 
 
Returns
-------
new_dtype : dtype
    New `dtypeobject with the given change to the byte order.
nonzero(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
prod(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
ptp(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
put(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
ravel(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
repeat(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
reshape(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
resize(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
round(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
searchsorted(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
setfield(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
setflags(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class so as to
provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
sort(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
squeeze(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
std(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
sum(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
swapaxes(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
take(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
tofile(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
tolist(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
tostring(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
trace(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
transpose(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
var(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.
view(...)
Not implemented (virtual attribute)
 
Class generic exists solely to derive numpy scalars from, and possesses,
albeit unimplemented, all the attributes of the ndarray class
so as to provide a uniform API.
 
See Also
--------
The corresponding attribute of the derived class of interest.

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

Methods inherited from __builtin__.float:
__coerce__(...)
x.__coerce__(y) <==> coerce(x, y)
__getattribute__(...)
x.__getattribute__('name') <==> x.name
__getformat__(...)
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.
__getnewargs__(...)
__hash__(...)
x.__hash__() <==> hash(x)
__setformat__(...)
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.
 
Override the automatic determination of C-level floating point type.
This affects how floats are converted to and from binary strings.
__trunc__(...)
Return the Integral closest to x between 0 and x.
as_integer_ratio(...)
float.as_integer_ratio() -> (intint)
 
Return a pair of integers, whose ratio is exactly equal to the original
float and with a positive denominator.
Raise 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)
fromhex(...)
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
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(...)
Return True if the float is an integer.

 
class dtype(__builtin__.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. If a struct dtype is being created,
    this also sets a sticky alignment flag ``isalignedstruct``.
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.
 
See also
--------
result_type
 
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.