Introduction to Python for Data Sciences |
Franck Iutzeler |
Python has a large standard library, commonly cited as one of Python's greatest strengths, providing tools suited to many tasks. As of May, 2017, the official repository containing third-party software for Python, contains over 107,000 packages.
A package is a collection of modules i.e. groups of functions, classes, constants, types, etc.
To use a module, you have to import it using the command import
.
import math
You can now use it in the code by using its name as a prefix.
x = math.cos(2 * math.pi)
print(x)
1.0
To explore the function and other content of the module/library:
math
library Doc for Python 3)help
help(math)
Help on built-in module math: NAME math DESCRIPTION This module provides access to the mathematical functions defined by the C standard. FUNCTIONS acos(x, /) Return the arc cosine (measured in radians) of x. acosh(x, /) Return the inverse hyperbolic cosine of x. asin(x, /) Return the arc sine (measured in radians) of x. asinh(x, /) Return the inverse hyperbolic sine of x. atan(x, /) Return the arc tangent (measured in radians) of x. atan2(y, x, /) Return the arc tangent (measured in radians) of y/x. Unlike atan(y/x), the signs of both x and y are considered. atanh(x, /) Return the inverse hyperbolic tangent of x. ceil(x, /) Return the ceiling of x as an Integral. This is the smallest integer >= x. comb(n, k, /) Number of ways to choose k items from n items without repetition and without order. Evaluates to n! / (k! * (n - k)!) when k <= n and evaluates to zero when k > n. Also called the binomial coefficient because it is equivalent to the coefficient of k-th term in polynomial expansion of the expression (1 + x)**n. Raises TypeError if either of the arguments are not integers. Raises ValueError if either of the arguments are negative. copysign(x, y, /) Return a float with the magnitude (absolute value) of x but the sign of y. On platforms that support signed zeros, copysign(1.0, -0.0) returns -1.0. cos(x, /) Return the cosine of x (measured in radians). cosh(x, /) Return the hyperbolic cosine of x. degrees(x, /) Convert angle x from radians to degrees. dist(p, q, /) Return the Euclidean distance between two points p and q. The points should be specified as sequences (or iterables) of coordinates. Both inputs must have the same dimension. Roughly equivalent to: sqrt(sum((px - qx) ** 2.0 for px, qx in zip(p, q))) erf(x, /) Error function at x. erfc(x, /) Complementary error function at x. exp(x, /) Return e raised to the power of x. expm1(x, /) Return exp(x)-1. This function avoids the loss of precision involved in the direct evaluation of exp(x)-1 for small x. fabs(x, /) Return the absolute value of the float x. factorial(x, /) Find x!. Raise a ValueError if x is negative or non-integral. floor(x, /) Return the floor of x as an Integral. This is the largest integer <= x. fmod(x, y, /) Return fmod(x, y), according to platform C. x % y may differ. frexp(x, /) Return the mantissa and exponent of x, as pair (m, e). m is a float and e is an int, such that x = m * 2.**e. If x is 0, m and e are both 0. Else 0.5 <= abs(m) < 1.0. fsum(seq, /) Return an accurate floating point sum of values in the iterable seq. Assumes IEEE-754 floating point arithmetic. gamma(x, /) Gamma function at x. gcd(x, y, /) greatest common divisor of x and y hypot(...) hypot(*coordinates) -> value Multidimensional Euclidean distance from the origin to a point. Roughly equivalent to: sqrt(sum(x**2 for x in coordinates)) For a two dimensional point (x, y), gives the hypotenuse using the Pythagorean theorem: sqrt(x*x + y*y). For example, the hypotenuse of a 3/4/5 right triangle is: >>> hypot(3.0, 4.0) 5.0 isclose(a, b, *, rel_tol=1e-09, abs_tol=0.0) Determine whether two floating point numbers are close in value. rel_tol maximum difference for being considered "close", relative to the magnitude of the input values abs_tol maximum difference for being considered "close", regardless of the magnitude of the input values Return True if a is close in value to b, and False otherwise. For the values to be considered close, the difference between them must be smaller than at least one of the tolerances. -inf, inf and NaN behave similarly to the IEEE 754 Standard. That is, NaN is not close to anything, even itself. inf and -inf are only close to themselves. isfinite(x, /) Return True if x is neither an infinity nor a NaN, and False otherwise. isinf(x, /) Return True if x is a positive or negative infinity, and False otherwise. isnan(x, /) Return True if x is a NaN (not a number), and False otherwise. isqrt(n, /) Return the integer part of the square root of the input. ldexp(x, i, /) Return x * (2**i). This is essentially the inverse of frexp(). lgamma(x, /) Natural logarithm of absolute value of Gamma function at x. log(...) log(x, [base=math.e]) Return the logarithm of x to the given base. If the base not specified, returns the natural logarithm (base e) of x. log10(x, /) Return the base 10 logarithm of x. log1p(x, /) Return the natural logarithm of 1+x (base e). The result is computed in a way which is accurate for x near zero. log2(x, /) Return the base 2 logarithm of x. modf(x, /) Return the fractional and integer parts of x. Both results carry the sign of x and are floats. perm(n, k=None, /) Number of ways to choose k items from n items without repetition and with order. Evaluates to n! / (n - k)! when k <= n and evaluates to zero when k > n. If k is not specified or is None, then k defaults to n and the function returns n!. Raises TypeError if either of the arguments are not integers. Raises ValueError if either of the arguments are negative. pow(x, y, /) Return x**y (x to the power of y). prod(iterable, /, *, start=1) Calculate the product of all the elements in the input iterable. The default start value for the product is 1. When the iterable is empty, return the start value. This function is intended specifically for use with numeric values and may reject non-numeric types. radians(x, /) Convert angle x from degrees to radians. remainder(x, y, /) Difference between x and the closest integer multiple of y. Return x - n*y where n*y is the closest integer multiple of y. In the case where x is exactly halfway between two multiples of y, the nearest even value of n is used. The result is always exact. sin(x, /) Return the sine of x (measured in radians). sinh(x, /) Return the hyperbolic sine of x. sqrt(x, /) Return the square root of x. tan(x, /) Return the tangent of x (measured in radians). tanh(x, /) Return the hyperbolic tangent of x. trunc(x, /) Truncates the Real x to the nearest Integral toward 0. Uses the __trunc__ magic method. DATA e = 2.718281828459045 inf = inf nan = nan pi = 3.141592653589793 tau = 6.283185307179586 FILE (built-in)
help(math.sqrt)
Help on built-in function sqrt in module math: sqrt(x, /) Return the square root of x.
Using the name prefix can make the code obfuscated as it can get quite verbose (e.g. scipy.optimize.minimize
) so Python provides simpler ways to import:
import name as nickname
: the prefix to call is now nickname
import math as m
print(m.pi)
3.141592653589793
from name import function1,constant1
: function1
constant1
can now be called directly. You can even import all contents with from name import *
but this may be dangerous as names may conflict or override former ones, it is thus not advised except on user-generated modules.from math import e,log
print(log(e**4))
4.0
Python comes with a lot a lot of packages (ie. functions and small programs), provided by the community. To install a package SomePackage
, the recommended way is know to use pip
:
python -m pip install SomePackage
or simply pip install SomePackage
See https://docs.python.org/3.9/installing/index.html for details on installing packages (and if you do not have pip
installed, see https://packaging.python.org/tutorials/installing-packages/#requirements-for-installing-packages )
Warning: this is the preferred way, however:
pip --user install SomePackage
to install a package locally.Once installed, you can import the packages as above.
import scipy
help(scipy)
Help on package scipy: NAME scipy DESCRIPTION SciPy: A scientific computing package for Python ================================================ Documentation is available in the docstrings and online at https://docs.scipy.org. Contents -------- SciPy imports all the functions from the NumPy namespace, and in addition provides: Subpackages ----------- Using any of these subpackages requires an explicit import. For example, ``import scipy.cluster``. :: cluster --- Vector Quantization / Kmeans fft --- Discrete Fourier transforms fftpack --- Legacy discrete Fourier transforms integrate --- Integration routines interpolate --- Interpolation Tools io --- Data input and output linalg --- Linear algebra routines linalg.blas --- Wrappers to BLAS library linalg.lapack --- Wrappers to LAPACK library misc --- Various utilities that don't have another home. ndimage --- N-D image package odr --- Orthogonal Distance Regression optimize --- Optimization Tools signal --- Signal Processing Tools signal.windows --- Window functions sparse --- Sparse Matrices sparse.linalg --- Sparse Linear Algebra sparse.linalg.dsolve --- Linear Solvers sparse.linalg.dsolve.umfpack --- :Interface to the UMFPACK library: Conjugate Gradient Method (LOBPCG) sparse.linalg.eigen --- Sparse Eigenvalue Solvers sparse.linalg.eigen.lobpcg --- Locally Optimal Block Preconditioned Conjugate Gradient Method (LOBPCG) spatial --- Spatial data structures and algorithms special --- Special functions stats --- Statistical Functions Utility tools ------------- :: test --- Run scipy unittests show_config --- Show scipy build configuration show_numpy_config --- Show numpy build configuration __version__ --- SciPy version string __numpy_version__ --- Numpy version string PACKAGE CONTENTS __config__ _build_utils (package) _distributor_init _lib (package) cluster (package) conftest constants (package) fft (package) fftpack (package) integrate (package) interpolate (package) io (package) linalg (package) misc (package) ndimage (package) odr (package) optimize (package) setup signal (package) sparse (package) spatial (package) special (package) stats (package) version CLASSES builtins.DeprecationWarning(builtins.Warning) numpy.ModuleDeprecationWarning builtins.IndexError(builtins.LookupError) numpy.AxisError(builtins.ValueError, builtins.IndexError) builtins.RuntimeError(builtins.Exception) numpy.TooHardError builtins.RuntimeWarning(builtins.Warning) numpy.ComplexWarning builtins.UserWarning(builtins.Warning) numpy.RankWarning numpy.VisibleDeprecationWarning builtins.ValueError(builtins.Exception) numpy.AxisError(builtins.ValueError, builtins.IndexError) builtins.bytes(builtins.object) numpy.bytes_(builtins.bytes, numpy.character) builtins.object numpy.DataSource numpy.MachAr numpy.broadcast numpy.busdaycalendar numpy.dtype numpy.finfo numpy.flatiter numpy.format_parser numpy.generic numpy.bool_ numpy.datetime64 numpy.flexible numpy.character numpy.bytes_(builtins.bytes, numpy.character) numpy.str_(builtins.str, numpy.character) numpy.void numpy.record numpy.number numpy.inexact numpy.complexfloating numpy.complex128(numpy.complexfloating, builtins.complex) numpy.complex256 numpy.complex64 numpy.floating numpy.float128 numpy.float16 numpy.float32 numpy.float64(numpy.floating, builtins.float) numpy.integer numpy.signedinteger numpy.int16 numpy.int32 numpy.int64 numpy.int8 numpy.longlong numpy.timedelta64 numpy.unsignedinteger numpy.uint16 numpy.uint32 numpy.uint64 numpy.uint8 numpy.ulonglong numpy.object_ numpy.iinfo numpy.ndarray numpy.chararray numpy.matrix numpy.memmap numpy.recarray numpy.ndenumerate numpy.ndindex numpy.nditer numpy.poly1d numpy.ufunc numpy.vectorize builtins.str(builtins.object) numpy.str_(builtins.str, numpy.character) contextlib.ContextDecorator(builtins.object) numpy.errstate class AxisError(builtins.ValueError, builtins.IndexError) | AxisError(axis, ndim=None, msg_prefix=None) | | Axis supplied was invalid. | | Method resolution order: | AxisError | builtins.ValueError | builtins.IndexError | builtins.LookupError | builtins.Exception | builtins.BaseException | builtins.object | | Methods defined here: | | __init__(self, axis, ndim=None, msg_prefix=None) | Initialize self. See help(type(self)) for accurate signature. | | ---------------------------------------------------------------------- | Data descriptors defined here: | | __weakref__ | list of weak references to the object (if defined) | | ---------------------------------------------------------------------- | Static methods inherited from builtins.ValueError: | | __new__(*args, **kwargs) from builtins.type | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Methods inherited from builtins.BaseException: | | __delattr__(self, name, /) | Implement delattr(self, name). | | __getattribute__(self, name, /) | Return getattr(self, name). | | __reduce__(...) | Helper for pickle. | | __repr__(self, /) | Return repr(self). | | __setattr__(self, name, value, /) | Implement setattr(self, name, value). | | __setstate__(...) | | __str__(self, /) | Return str(self). | | with_traceback(...) | Exception.with_traceback(tb) -- | set self.__traceback__ to tb and return self. | | ---------------------------------------------------------------------- | Data descriptors inherited from builtins.BaseException: | | __cause__ | exception cause | | __context__ | exception context | | __dict__ | | __suppress_context__ | | __traceback__ | | args class ComplexWarning(builtins.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 | builtins.RuntimeWarning | builtins.Warning | builtins.Exception | builtins.BaseException | builtins.object | | Data descriptors defined here: | | __weakref__ | list of weak references to the object (if defined) | | ---------------------------------------------------------------------- | Methods inherited from builtins.RuntimeWarning: | | __init__(self, /, *args, **kwargs) | Initialize self. See help(type(self)) for accurate signature. | | ---------------------------------------------------------------------- | Static methods inherited from builtins.RuntimeWarning: | | __new__(*args, **kwargs) from builtins.type | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Methods inherited from builtins.BaseException: | | __delattr__(self, name, /) | Implement delattr(self, name). | | __getattribute__(self, name, /) | Return getattr(self, name). | | __reduce__(...) | Helper for pickle. | | __repr__(self, /) | Return repr(self). | | __setattr__(self, name, value, /) | Implement setattr(self, name, value). | | __setstate__(...) | | __str__(self, /) | Return str(self). | | with_traceback(...) | Exception.with_traceback(tb) -- | set self.__traceback__ to tb and return self. | | ---------------------------------------------------------------------- | Data descriptors inherited from builtins.BaseException: | | __cause__ | exception cause | | __context__ | exception context | | __dict__ | | __suppress_context__ | | __traceback__ | | args class DataSource(builtins.object) | DataSource(destpath='.') | | DataSource(destpath='.') | | A 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 = np.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 = np.DataSource('/home/guido') | >>> urlname = 'http://www.google.com/' | >>> gfile = ds.open('http://www.google.com/') | >>> ds.abspath(urlname) | '/home/guido/www.google.com/index.html' | | >>> ds = np.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/.../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', encoding=None, newline=None) | 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'. | encoding : {None, str}, optional | Open text file with given encoding. The default encoding will be | what `io.open` uses. | newline : {None, str}, optional | Newline to use when reading text file. | | 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(builtins.object) | MachAr(float_conv=<class 'float'>, int_conv=<class 'int'>, float_to_float=<class 'float'>, float_to_str=<function MachAr.<lambda> at 0x7f99240989d0>, title='Python floating point number') | | 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, subtracted | 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=<class 'float'>, int_conv=<class 'int'>, float_to_float=<class 'float'>, float_to_str=<function MachAr.<lambda> at 0x7f99240989d0>, 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) | Return 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(builtins.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 | builtins.DeprecationWarning | builtins.Warning | builtins.Exception | builtins.BaseException | builtins.object | | Data descriptors defined here: | | __weakref__ | list of weak references to the object (if defined) | | ---------------------------------------------------------------------- | Methods inherited from builtins.DeprecationWarning: | | __init__(self, /, *args, **kwargs) | Initialize self. See help(type(self)) for accurate signature. | | ---------------------------------------------------------------------- | Static methods inherited from builtins.DeprecationWarning: | | __new__(*args, **kwargs) from builtins.type | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Methods inherited from builtins.BaseException: | | __delattr__(self, name, /) | Implement delattr(self, name). | | __getattribute__(self, name, /) | Return getattr(self, name). | | __reduce__(...) | Helper for pickle. | | __repr__(self, /) | Return repr(self). | | __setattr__(self, name, value, /) | Implement setattr(self, name, value). | | __setstate__(...) | | __str__(self, /) | Return str(self). | | with_traceback(...) | Exception.with_traceback(tb) -- | set self.__traceback__ to tb and return self. | | ---------------------------------------------------------------------- | Data descriptors inherited from builtins.BaseException: | | __cause__ | exception cause | | __context__ | exception context | | __dict__ | | __suppress_context__ | | __traceback__ | | args class RankWarning(builtins.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 | builtins.UserWarning | builtins.Warning | builtins.Exception | builtins.BaseException | builtins.object | | Data descriptors defined here: | | __weakref__ | list of weak references to the object (if defined) | | ---------------------------------------------------------------------- | Methods inherited from builtins.UserWarning: | | __init__(self, /, *args, **kwargs) | Initialize self. See help(type(self)) for accurate signature. | | ---------------------------------------------------------------------- | Static methods inherited from builtins.UserWarning: | | __new__(*args, **kwargs) from builtins.type | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Methods inherited from builtins.BaseException: | | __delattr__(self, name, /) | Implement delattr(self, name). | | __getattribute__(self, name, /) | Return getattr(self, name). | | __reduce__(...) | Helper for pickle. | | __repr__(self, /) | Return repr(self). | | __setattr__(self, name, value, /) | Implement setattr(self, name, value). | | __setstate__(...) | | __str__(self, /) | Return str(self). | | with_traceback(...) | Exception.with_traceback(tb) -- | set self.__traceback__ to tb and return self. | | ---------------------------------------------------------------------- | Data descriptors inherited from builtins.BaseException: | | __cause__ | exception cause | | __context__ | exception context | | __dict__ | | __suppress_context__ | | __traceback__ | | args class TooHardError(builtins.RuntimeError) | Unspecified run-time error. | | Method resolution order: | TooHardError | builtins.RuntimeError | builtins.Exception | builtins.BaseException | builtins.object | | Data descriptors defined here: | | __weakref__ | list of weak references to the object (if defined) | | ---------------------------------------------------------------------- | Methods inherited from builtins.RuntimeError: | | __init__(self, /, *args, **kwargs) | Initialize self. See help(type(self)) for accurate signature. | | ---------------------------------------------------------------------- | Static methods inherited from builtins.RuntimeError: | | __new__(*args, **kwargs) from builtins.type | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Methods inherited from builtins.BaseException: | | __delattr__(self, name, /) | Implement delattr(self, name). | | __getattribute__(self, name, /) | Return getattr(self, name). | | __reduce__(...) | Helper for pickle. | | __repr__(self, /) | Return repr(self). | | __setattr__(self, name, value, /) | Implement setattr(self, name, value). | | __setstate__(...) | | __str__(self, /) | Return str(self). | | with_traceback(...) | Exception.with_traceback(tb) -- | set self.__traceback__ to tb and return self. | | ---------------------------------------------------------------------- | Data descriptors inherited from builtins.BaseException: | | __cause__ | exception cause | | __context__ | exception context | | __dict__ | | __suppress_context__ | | __traceback__ | | args class VisibleDeprecationWarning(builtins.UserWarning) | Visible deprecation warning. | | By default, python will not show deprecation warnings, so this class | can be used when a very visible warning is helpful, for example because | the usage is most likely a user bug. | | Method resolution order: | VisibleDeprecationWarning | builtins.UserWarning | builtins.Warning | builtins.Exception | builtins.BaseException | builtins.object | | Data descriptors defined here: | | __weakref__ | list of weak references to the object (if defined) | | ---------------------------------------------------------------------- | Methods inherited from builtins.UserWarning: | | __init__(self, /, *args, **kwargs) | Initialize self. See help(type(self)) for accurate signature. | | ---------------------------------------------------------------------- | Static methods inherited from builtins.UserWarning: | | __new__(*args, **kwargs) from builtins.type | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Methods inherited from builtins.BaseException: | | __delattr__(self, name, /) | Implement delattr(self, name). | | __getattribute__(self, name, /) | Return getattr(self, name). | | __reduce__(...) | Helper for pickle. | | __repr__(self, /) | Return repr(self). | | __setattr__(self, name, value, /) | Implement setattr(self, name, value). | | __setstate__(...) | | __str__(self, /) | Return str(self). | | with_traceback(...) | Exception.with_traceback(tb) -- | set self.__traceback__ to tb and return self. | | ---------------------------------------------------------------------- | Data descriptors inherited from builtins.BaseException: | | __cause__ | exception cause | | __context__ | exception context | | __dict__ | | __suppress_context__ | | __traceback__ | | args bool8 = class bool_(generic) | Boolean type (True or False), stored as a byte. | Character code: ``'?'``. | Alias: ``np.bool8``. | | Method resolution order: | bool_ | generic | builtins.object | | Methods defined here: | | __and__(self, value, /) | Return self&value. | | __bool__(self, /) | self != 0 | | __eq__(self, value, /) | Return self==value. | | __ge__(self, value, /) | Return self>=value. | | __gt__(self, value, /) | Return self>value. | | __hash__(self, /) | Return hash(self). | | __index__(self, /) | Return self converted to an integer, if self is suitable for use as an index into a list. | | __le__(self, value, /) | Return self<=value. | | __lt__(self, value, /) | Return self<value. | | __ne__(self, value, /) | Return self!=value. | | __or__(self, value, /) | Return self|value. | | __rand__(self, value, /) | Return value&self. | | __repr__(self, /) | Return repr(self). | | __ror__(self, value, /) | Return value|self. | | __rxor__(self, value, /) | Return value^self. | | __str__(self, /) | Return str(self). | | __xor__(self, value, /) | Return self^value. | | ---------------------------------------------------------------------- | Static methods defined here: | | __new__(*args, **kwargs) from builtins.type | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Methods inherited from generic: | | __abs__(self, /) | abs(self) | | __add__(self, value, /) | Return self+value. | | __array__(...) | sc.__array__(dtype) return 0-dim array from scalar with specified dtype | | __array_wrap__(...) | sc.__array_wrap__(obj) return scalar from array | | __copy__(...) | | __deepcopy__(...) | | __divmod__(self, value, /) | Return divmod(self, value). | | __float__(self, /) | float(self) | | __floordiv__(self, value, /) | Return self//value. | | __format__(...) | NumPy array scalar formatter | | __getitem__(self, key, /) | Return self[key]. | | __int__(self, /) | int(self) | | __invert__(self, /) | ~self | | __lshift__(self, value, /) | Return self<<value. | | __mod__(self, value, /) | Return self%value. | | __mul__(self, value, /) | Return self*value. | | __neg__(self, /) | -self | | __pos__(self, /) | +self | | __pow__(self, value, mod=None, /) | Return pow(self, value, mod). | | __radd__(self, value, /) | Return value+self. | | __rdivmod__(self, value, /) | Return divmod(value, self). | | __reduce__(...) | Helper for pickle. | | __rfloordiv__(self, value, /) | Return value//self. | | __rlshift__(self, value, /) | Return value<<self. | | __rmod__(self, value, /) | Return value%self. | | __rmul__(self, value, /) | Return value*self. | | __rpow__(self, value, mod=None, /) | Return pow(value, self, mod). | | __rrshift__(self, value, /) | Return value>>self. | | __rshift__(self, value, /) | Return self>>value. | | __rsub__(self, value, /) | Return value-self. | | __rtruediv__(self, value, /) | Return value/self. | | __setstate__(...) | | __sizeof__(...) | Size of object in memory, in bytes. | | __sub__(self, value, /) | Return self-value. | | __truediv__(self, value, /) | Return self/value. | | all(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | getfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | base | base object | | data | pointer to start of data | | dtype | get array data-descriptor | | flags | integer value of flags | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension class bool_(generic) | Boolean type (True or False), stored as a byte. | Character code: ``'?'``. | Alias: ``np.bool8``. | | Method resolution order: | bool_ | generic | builtins.object | | Methods defined here: | | __and__(self, value, /) | Return self&value. | | __bool__(self, /) | self != 0 | | __eq__(self, value, /) | Return self==value. | | __ge__(self, value, /) | Return self>=value. | | __gt__(self, value, /) | Return self>value. | | __hash__(self, /) | Return hash(self). | | __index__(self, /) | Return self converted to an integer, if self is suitable for use as an index into a list. | | __le__(self, value, /) | Return self<=value. | | __lt__(self, value, /) | Return self<value. | | __ne__(self, value, /) | Return self!=value. | | __or__(self, value, /) | Return self|value. | | __rand__(self, value, /) | Return value&self. | | __repr__(self, /) | Return repr(self). | | __ror__(self, value, /) | Return value|self. | | __rxor__(self, value, /) | Return value^self. | | __str__(self, /) | Return str(self). | | __xor__(self, value, /) | Return self^value. | | ---------------------------------------------------------------------- | Static methods defined here: | | __new__(*args, **kwargs) from builtins.type | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Methods inherited from generic: | | __abs__(self, /) | abs(self) | | __add__(self, value, /) | Return self+value. | | __array__(...) | sc.__array__(dtype) return 0-dim array from scalar with specified dtype | | __array_wrap__(...) | sc.__array_wrap__(obj) return scalar from array | | __copy__(...) | | __deepcopy__(...) | | __divmod__(self, value, /) | Return divmod(self, value). | | __float__(self, /) | float(self) | | __floordiv__(self, value, /) | Return self//value. | | __format__(...) | NumPy array scalar formatter | | __getitem__(self, key, /) | Return self[key]. | | __int__(self, /) | int(self) | | __invert__(self, /) | ~self | | __lshift__(self, value, /) | Return self<<value. | | __mod__(self, value, /) | Return self%value. | | __mul__(self, value, /) | Return self*value. | | __neg__(self, /) | -self | | __pos__(self, /) | +self | | __pow__(self, value, mod=None, /) | Return pow(self, value, mod). | | __radd__(self, value, /) | Return value+self. | | __rdivmod__(self, value, /) | Return divmod(value, self). | | __reduce__(...) | Helper for pickle. | | __rfloordiv__(self, value, /) | Return value//self. | | __rlshift__(self, value, /) | Return value<<self. | | __rmod__(self, value, /) | Return value%self. | | __rmul__(self, value, /) | Return value*self. | | __rpow__(self, value, mod=None, /) | Return pow(value, self, mod). | | __rrshift__(self, value, /) | Return value>>self. | | __rshift__(self, value, /) | Return self>>value. | | __rsub__(self, value, /) | Return value-self. | | __rtruediv__(self, value, /) | Return value/self. | | __setstate__(...) | | __sizeof__(...) | Size of object in memory, in bytes. | | __sub__(self, value, /) | Return self-value. | | __truediv__(self, value, /) | Return self/value. | | all(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | getfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | base | base object | | data | pointer to start of data | | dtype | get array data-descriptor | | flags | integer value of flags | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension class broadcast(builtins.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. | | See Also | -------- | broadcast_arrays | broadcast_to | | 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__(self, /) | Implement iter(self). | | __next__(self, /) | Implement next(self). | | 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 | >>> next(b), next(b), next(b) | ((1, 4), (2, 4), (3, 4)) | >>> b.index | 3 | >>> b.reset() | >>> b.index | 0 | | ---------------------------------------------------------------------- | Static methods defined here: | | __new__(*args, **kwargs) from builtins.type | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | 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 | >>> next(b), next(b), next(b) | ((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 | >>> next(row), next(col) | (1, 4) | | nd | Number of dimensions of broadcasted result. For code intended for NumPy | 1.12.0 and later the more consistent `ndim` is preferred. | | Examples | -------- | >>> x = np.array([1, 2, 3]) | >>> y = np.array([[4], [5], [6]]) | >>> b = np.broadcast(x, y) | >>> b.nd | 2 | | ndim | Number of dimensions of broadcasted result. Alias for `nd`. | | .. versionadded:: 1.12.0 | | Examples | -------- | >>> x = np.array([1, 2, 3]) | >>> y = np.array([[4], [5], [6]]) | >>> b = np.broadcast(x, y) | >>> b.ndim | 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 class busdaycalendar(builtins.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"). | A 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]) | >>> # Any holidays already on the weekend are removed | ... bdd.holidays | array(['2011-07-01', '2011-07-04'], dtype='datetime64[D]') | | Methods defined here: | | __init__(self, /, *args, **kwargs) | Initialize self. See help(type(self)) for accurate signature. | | ---------------------------------------------------------------------- | Static methods defined here: | | __new__(*args, **kwargs) from builtins.type | Create and return a new object. See help(type) for accurate 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. byte = class int8(signedinteger) | Signed integer type, compatible with C ``char``. | Character code: ``'b'``. | Canonical name: ``np.byte``. | Alias *on this platform*: ``np.int8``: 8-bit signed integer (-128 to 127). | | Method resolution order: | int8 | signedinteger | integer | number | generic | builtins.object | | Methods defined here: | | __abs__(self, /) | abs(self) | | __add__(self, value, /) | Return self+value. | | __and__(self, value, /) | Return self&value. | | __bool__(self, /) | self != 0 | | __divmod__(self, value, /) | Return divmod(self, value). | | __eq__(self, value, /) | Return self==value. | | __float__(self, /) | float(self) | | __floordiv__(self, value, /) | Return self//value. | | __ge__(self, value, /) | Return self>=value. | | __gt__(self, value, /) | Return self>value. | | __hash__(self, /) | Return hash(self). | | __index__(self, /) | Return self converted to an integer, if self is suitable for use as an index into a list. | | __int__(self, /) | int(self) | | __invert__(self, /) | ~self | | __le__(self, value, /) | Return self<=value. | | __lshift__(self, value, /) | Return self<<value. | | __lt__(self, value, /) | Return self<value. | | __mod__(self, value, /) | Return self%value. | | __mul__(self, value, /) | Return self*value. | | __ne__(self, value, /) | Return self!=value. | | __neg__(self, /) | -self | | __or__(self, value, /) | Return self|value. | | __pos__(self, /) | +self | | __pow__(self, value, mod=None, /) | Return pow(self, value, mod). | | __radd__(self, value, /) | Return value+self. | | __rand__(self, value, /) | Return value&self. | | __rdivmod__(self, value, /) | Return divmod(value, self). | | __repr__(self, /) | Return repr(self). | | __rfloordiv__(self, value, /) | Return value//self. | | __rlshift__(self, value, /) | Return value<<self. | | __rmod__(self, value, /) | Return value%self. | | __rmul__(self, value, /) | Return value*self. | | __ror__(self, value, /) | Return value|self. | | __rpow__(self, value, mod=None, /) | Return pow(value, self, mod). | | __rrshift__(self, value, /) | Return value>>self. | | __rshift__(self, value, /) | Return self>>value. | | __rsub__(self, value, /) | Return value-self. | | __rtruediv__(self, value, /) | Return value/self. | | __rxor__(self, value, /) | Return value^self. | | __str__(self, /) | Return str(self). | | __sub__(self, value, /) | Return self-value. | | __truediv__(self, value, /) | Return self/value. | | __xor__(self, value, /) | Return self^value. | | ---------------------------------------------------------------------- | Static methods defined here: | | __new__(*args, **kwargs) from builtins.type | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Methods inherited from integer: | | __round__(...) | | ---------------------------------------------------------------------- | Data descriptors inherited from integer: | | denominator | denominator of value (1) | | numerator | numerator of value (the value itself) | | ---------------------------------------------------------------------- | Methods inherited from generic: | | __array__(...) | sc.__array__(dtype) return 0-dim array from scalar with specified dtype | | __array_wrap__(...) | sc.__array_wrap__(obj) return scalar from array | | __copy__(...) | | __deepcopy__(...) | | __format__(...) | NumPy array scalar formatter | | __getitem__(self, key, /) | Return self[key]. | | __reduce__(...) | Helper for pickle. | | __setstate__(...) | | __sizeof__(...) | Size of object in memory, in bytes. | | all(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | getfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | base | base object | | data | pointer to start of data | | dtype | get array data-descriptor | | flags | integer value of flags | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension bytes0 = class bytes_(builtins.bytes, character) | bytes(iterable_of_ints) -> bytes | bytes(string, encoding[, errors]) -> bytes | bytes(bytes_or_buffer) -> immutable copy of bytes_or_buffer | bytes(int) -> bytes object of size given by the parameter initialized with null bytes | bytes() -> empty bytes object | | Construct an immutable array of bytes from: | - an iterable yielding integers in range(256) | - a text string encoded using the specified encoding | - any object implementing the buffer API. | - an integer | | Method resolution order: | bytes_ | builtins.bytes | character | flexible | generic | builtins.object | | Methods defined here: | | __eq__(self, value, /) | Return self==value. | | __ge__(self, value, /) | Return self>=value. | | __gt__(self, value, /) | Return self>value. | | __hash__(self, /) | Return hash(self). | | __le__(self, value, /) | Return self<=value. | | __lt__(self, value, /) | Return self<value. | | __ne__(self, value, /) | Return self!=value. | | __repr__(self, /) | Return repr(self). | | __str__(self, /) | Return str(self). | | ---------------------------------------------------------------------- | Static methods defined here: | | __new__(*args, **kwargs) from builtins.type | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Methods inherited from builtins.bytes: | | __add__(self, value, /) | Return self+value. | | __contains__(self, key, /) | Return key in self. | | __getattribute__(self, name, /) | Return getattr(self, name). | | __getitem__(self, key, /) | Return self[key]. | | __getnewargs__(...) | | __iter__(self, /) | Implement iter(self). | | __len__(self, /) | Return len(self). | | __mod__(self, value, /) | Return self%value. | | __mul__(self, value, /) | Return self*value. | | __rmod__(self, value, /) | Return value%self. | | __rmul__(self, value, /) | Return value*self. | | capitalize(...) | B.capitalize() -> copy of B | | Return a copy of B with only its first character capitalized (ASCII) | and the rest lower-cased. | | center(self, width, fillchar=b' ', /) | Return a centered string of length width. | | Padding is done using the specified fill character. | | count(...) | B.count(sub[, start[, end]]) -> int | | Return the number of non-overlapping occurrences of subsection sub in | bytes B[start:end]. Optional arguments start and end are interpreted | as in slice notation. | | decode(self, /, encoding='utf-8', errors='strict') | Decode the bytes using the codec registered for encoding. | | encoding | The encoding with which to decode the bytes. | errors | The error handling scheme to use for the handling of decoding errors. | The default is 'strict' meaning that decoding errors raise a | UnicodeDecodeError. Other possible values are 'ignore' and 'replace' | as well as any other name registered with codecs.register_error that | can handle UnicodeDecodeErrors. | | endswith(...) | B.endswith(suffix[, start[, end]]) -> bool | | Return True if B ends with the specified suffix, False otherwise. | With optional start, test B beginning at that position. | With optional end, stop comparing B at that position. | suffix can also be a tuple of bytes to try. | | expandtabs(self, /, tabsize=8) | Return a copy where all tab characters are expanded using spaces. | | If tabsize is not given, a tab size of 8 characters is assumed. | | find(...) | B.find(sub[, start[, end]]) -> int | | Return the lowest index in B where subsection sub is found, | such that sub is contained within B[start,end]. Optional | arguments start and end are interpreted as in slice notation. | | Return -1 on failure. | | hex(...) | Create a str of hexadecimal numbers from a bytes object. | | sep | An optional single character or byte to separate hex bytes. | bytes_per_sep | How many bytes between separators. Positive values count from the | right, negative values count from the left. | | Example: | >>> value = b'\xb9\x01\xef' | >>> value.hex() | 'b901ef' | >>> value.hex(':') | 'b9:01:ef' | >>> value.hex(':', 2) | 'b9:01ef' | >>> value.hex(':', -2) | 'b901:ef' | | index(...) | B.index(sub[, start[, end]]) -> int | | Return the lowest index in B where subsection sub is found, | such that sub is contained within B[start,end]. Optional | arguments start and end are interpreted as in slice notation. | | Raises ValueError when the subsection is not found. | | isalnum(...) | B.isalnum() -> bool | | Return True if all characters in B are alphanumeric | and there is at least one character in B, False otherwise. | | isalpha(...) | B.isalpha() -> bool | | Return True if all characters in B are alphabetic | and there is at least one character in B, False otherwise. | | isascii(...) | B.isascii() -> bool | | Return True if B is empty or all characters in B are ASCII, | False otherwise. | | isdigit(...) | B.isdigit() -> bool | | Return True if all characters in B are digits | and there is at least one character in B, False otherwise. | | islower(...) | B.islower() -> bool | | Return True if all cased characters in B are lowercase and there is | at least one cased character in B, False otherwise. | | isspace(...) | B.isspace() -> bool | | Return True if all characters in B are whitespace | and there is at least one character in B, False otherwise. | | istitle(...) | B.istitle() -> bool | | Return True if B is a titlecased string and there is at least one | character in B, i.e. uppercase characters may only follow uncased | characters and lowercase characters only cased ones. Return False | otherwise. | | isupper(...) | B.isupper() -> bool | | Return True if all cased characters in B are uppercase and there is | at least one cased character in B, False otherwise. | | join(self, iterable_of_bytes, /) | Concatenate any number of bytes objects. | | The bytes whose method is called is inserted in between each pair. | | The result is returned as a new bytes object. | | Example: b'.'.join([b'ab', b'pq', b'rs']) -> b'ab.pq.rs'. | | ljust(self, width, fillchar=b' ', /) | Return a left-justified string of length width. | | Padding is done using the specified fill character. | | lower(...) | B.lower() -> copy of B | | Return a copy of B with all ASCII characters converted to lowercase. | | lstrip(self, bytes=None, /) | Strip leading bytes contained in the argument. | | If the argument is omitted or None, strip leading ASCII whitespace. | | partition(self, sep, /) | Partition the bytes into three parts using the given separator. | | This will search for the separator sep in the bytes. If the separator is found, | returns a 3-tuple containing the part before the separator, the separator | itself, and the part after it. | | If the separator is not found, returns a 3-tuple containing the original bytes | object and two empty bytes objects. | | replace(self, old, new, count=-1, /) | Return a copy with all occurrences of substring old replaced by new. | | count | Maximum number of occurrences to replace. | -1 (the default value) means replace all occurrences. | | If the optional argument count is given, only the first count occurrences are | replaced. | | rfind(...) | B.rfind(sub[, start[, end]]) -> int | | Return the highest index in B where subsection sub is found, | such that sub is contained within B[start,end]. Optional | arguments start and end are interpreted as in slice notation. | | Return -1 on failure. | | rindex(...) | B.rindex(sub[, start[, end]]) -> int | | Return the highest index in B where subsection sub is found, | such that sub is contained within B[start,end]. Optional | arguments start and end are interpreted as in slice notation. | | Raise ValueError when the subsection is not found. | | rjust(self, width, fillchar=b' ', /) | Return a right-justified string of length width. | | Padding is done using the specified fill character. | | rpartition(self, sep, /) | Partition the bytes into three parts using the given separator. | | This will search for the separator sep in the bytes, starting at the end. If | the separator is found, returns a 3-tuple containing the part before the | separator, the separator itself, and the part after it. | | If the separator is not found, returns a 3-tuple containing two empty bytes | objects and the original bytes object. | | rsplit(self, /, sep=None, maxsplit=-1) | Return a list of the sections in the bytes, using sep as the delimiter. | | sep | The delimiter according which to split the bytes. | None (the default value) means split on ASCII whitespace characters | (space, tab, return, newline, formfeed, vertical tab). | maxsplit | Maximum number of splits to do. | -1 (the default value) means no limit. | | Splitting is done starting at the end of the bytes and working to the front. | | rstrip(self, bytes=None, /) | Strip trailing bytes contained in the argument. | | If the argument is omitted or None, strip trailing ASCII whitespace. | | split(self, /, sep=None, maxsplit=-1) | Return a list of the sections in the bytes, using sep as the delimiter. | | sep | The delimiter according which to split the bytes. | None (the default value) means split on ASCII whitespace characters | (space, tab, return, newline, formfeed, vertical tab). | maxsplit | Maximum number of splits to do. | -1 (the default value) means no limit. | | splitlines(self, /, keepends=False) | Return a list of the lines in the bytes, breaking at line boundaries. | | Line breaks are not included in the resulting list unless keepends is given and | true. | | startswith(...) | B.startswith(prefix[, start[, end]]) -> bool | | Return True if B starts with the specified prefix, False otherwise. | With optional start, test B beginning at that position. | With optional end, stop comparing B at that position. | prefix can also be a tuple of bytes to try. | | strip(self, bytes=None, /) | Strip leading and trailing bytes contained in the argument. | | If the argument is omitted or None, strip leading and trailing ASCII whitespace. | | swapcase(...) | B.swapcase() -> copy of B | | Return a copy of B with uppercase ASCII characters converted | to lowercase ASCII and vice versa. | | title(...) | B.title() -> copy of B | | Return a titlecased version of B, i.e. ASCII words start with uppercase | characters, all remaining cased characters have lowercase. | | translate(self, table, /, delete=b'') | Return a copy with each character mapped by the given translation table. | | table | Translation table, which must be a bytes object of length 256. | | All characters occurring in the optional argument delete are removed. | The remaining characters are mapped through the given translation table. | | upper(...) | B.upper() -> copy of B | | Return a copy of B with all ASCII characters converted to uppercase. | | zfill(self, width, /) | Pad a numeric string with zeros on the left, to fill a field of the given width. | | The original string is never truncated. | | ---------------------------------------------------------------------- | Class methods inherited from builtins.bytes: | | fromhex(string, /) from builtins.type | Create a bytes object from a string of hexadecimal numbers. | | Spaces between two numbers are accepted. | Example: bytes.fromhex('B9 01EF') -> b'\\xb9\\x01\\xef'. | | ---------------------------------------------------------------------- | Static methods inherited from builtins.bytes: | | maketrans(frm, to, /) | Return a translation table useable for the bytes or bytearray translate method. | | The returned table will be one where each byte in frm is mapped to the byte at | the same position in to. | | The bytes objects frm and to must be of the same length. | | ---------------------------------------------------------------------- | Methods inherited from generic: | | __abs__(self, /) | abs(self) | | __and__(self, value, /) | Return self&value. | | __array__(...) | sc.__array__(dtype) return 0-dim array from scalar with specified dtype | | __array_wrap__(...) | sc.__array_wrap__(obj) return scalar from array | | __bool__(self, /) | self != 0 | | __copy__(...) | | __deepcopy__(...) | | __divmod__(self, value, /) | Return divmod(self, value). | | __float__(self, /) | float(self) | | __floordiv__(self, value, /) | Return self//value. | | __format__(...) | NumPy array scalar formatter | | __int__(self, /) | int(self) | | __invert__(self, /) | ~self | | __lshift__(self, value, /) | Return self<<value. | | __neg__(self, /) | -self | | __or__(self, value, /) | Return self|value. | | __pos__(self, /) | +self | | __pow__(self, value, mod=None, /) | Return pow(self, value, mod). | | __radd__(self, value, /) | Return value+self. | | __rand__(self, value, /) | Return value&self. | | __rdivmod__(self, value, /) | Return divmod(value, self). | | __reduce__(...) | Helper for pickle. | | __rfloordiv__(self, value, /) | Return value//self. | | __rlshift__(self, value, /) | Return value<<self. | | __ror__(self, value, /) | Return value|self. | | __rpow__(self, value, mod=None, /) | Return pow(value, self, mod). | | __rrshift__(self, value, /) | Return value>>self. | | __rshift__(self, value, /) | Return self>>value. | | __rsub__(self, value, /) | Return value-self. | | __rtruediv__(self, value, /) | Return value/self. | | __rxor__(self, value, /) | Return value^self. | | __setstate__(...) | | __sizeof__(...) | Size of object in memory, in bytes. | | __sub__(self, value, /) | Return self-value. | | __truediv__(self, value, /) | Return self/value. | | __xor__(self, value, /) | Return self^value. | | all(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | getfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | base | base object | | data | pointer to start of data | | dtype | get array data-descriptor | | flags | integer value of flags | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension class bytes_(builtins.bytes, character) | bytes(iterable_of_ints) -> bytes | bytes(string, encoding[, errors]) -> bytes | bytes(bytes_or_buffer) -> immutable copy of bytes_or_buffer | bytes(int) -> bytes object of size given by the parameter initialized with null bytes | bytes() -> empty bytes object | | Construct an immutable array of bytes from: | - an iterable yielding integers in range(256) | - a text string encoded using the specified encoding | - any object implementing the buffer API. | - an integer | | Method resolution order: | bytes_ | builtins.bytes | character | flexible | generic | builtins.object | | Methods defined here: | | __eq__(self, value, /) | Return self==value. | | __ge__(self, value, /) | Return self>=value. | | __gt__(self, value, /) | Return self>value. | | __hash__(self, /) | Return hash(self). | | __le__(self, value, /) | Return self<=value. | | __lt__(self, value, /) | Return self<value. | | __ne__(self, value, /) | Return self!=value. | | __repr__(self, /) | Return repr(self). | | __str__(self, /) | Return str(self). | | ---------------------------------------------------------------------- | Static methods defined here: | | __new__(*args, **kwargs) from builtins.type | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Methods inherited from builtins.bytes: | | __add__(self, value, /) | Return self+value. | | __contains__(self, key, /) | Return key in self. | | __getattribute__(self, name, /) | Return getattr(self, name). | | __getitem__(self, key, /) | Return self[key]. | | __getnewargs__(...) | | __iter__(self, /) | Implement iter(self). | | __len__(self, /) | Return len(self). | | __mod__(self, value, /) | Return self%value. | | __mul__(self, value, /) | Return self*value. | | __rmod__(self, value, /) | Return value%self. | | __rmul__(self, value, /) | Return value*self. | | capitalize(...) | B.capitalize() -> copy of B | | Return a copy of B with only its first character capitalized (ASCII) | and the rest lower-cased. | | center(self, width, fillchar=b' ', /) | Return a centered string of length width. | | Padding is done using the specified fill character. | | count(...) | B.count(sub[, start[, end]]) -> int | | Return the number of non-overlapping occurrences of subsection sub in | bytes B[start:end]. Optional arguments start and end are interpreted | as in slice notation. | | decode(self, /, encoding='utf-8', errors='strict') | Decode the bytes using the codec registered for encoding. | | encoding | The encoding with which to decode the bytes. | errors | The error handling scheme to use for the handling of decoding errors. | The default is 'strict' meaning that decoding errors raise a | UnicodeDecodeError. Other possible values are 'ignore' and 'replace' | as well as any other name registered with codecs.register_error that | can handle UnicodeDecodeErrors. | | endswith(...) | B.endswith(suffix[, start[, end]]) -> bool | | Return True if B ends with the specified suffix, False otherwise. | With optional start, test B beginning at that position. | With optional end, stop comparing B at that position. | suffix can also be a tuple of bytes to try. | | expandtabs(self, /, tabsize=8) | Return a copy where all tab characters are expanded using spaces. | | If tabsize is not given, a tab size of 8 characters is assumed. | | find(...) | B.find(sub[, start[, end]]) -> int | | Return the lowest index in B where subsection sub is found, | such that sub is contained within B[start,end]. Optional | arguments start and end are interpreted as in slice notation. | | Return -1 on failure. | | hex(...) | Create a str of hexadecimal numbers from a bytes object. | | sep | An optional single character or byte to separate hex bytes. | bytes_per_sep | How many bytes between separators. Positive values count from the | right, negative values count from the left. | | Example: | >>> value = b'\xb9\x01\xef' | >>> value.hex() | 'b901ef' | >>> value.hex(':') | 'b9:01:ef' | >>> value.hex(':', 2) | 'b9:01ef' | >>> value.hex(':', -2) | 'b901:ef' | | index(...) | B.index(sub[, start[, end]]) -> int | | Return the lowest index in B where subsection sub is found, | such that sub is contained within B[start,end]. Optional | arguments start and end are interpreted as in slice notation. | | Raises ValueError when the subsection is not found. | | isalnum(...) | B.isalnum() -> bool | | Return True if all characters in B are alphanumeric | and there is at least one character in B, False otherwise. | | isalpha(...) | B.isalpha() -> bool | | Return True if all characters in B are alphabetic | and there is at least one character in B, False otherwise. | | isascii(...) | B.isascii() -> bool | | Return True if B is empty or all characters in B are ASCII, | False otherwise. | | isdigit(...) | B.isdigit() -> bool | | Return True if all characters in B are digits | and there is at least one character in B, False otherwise. | | islower(...) | B.islower() -> bool | | Return True if all cased characters in B are lowercase and there is | at least one cased character in B, False otherwise. | | isspace(...) | B.isspace() -> bool | | Return True if all characters in B are whitespace | and there is at least one character in B, False otherwise. | | istitle(...) | B.istitle() -> bool | | Return True if B is a titlecased string and there is at least one | character in B, i.e. uppercase characters may only follow uncased | characters and lowercase characters only cased ones. Return False | otherwise. | | isupper(...) | B.isupper() -> bool | | Return True if all cased characters in B are uppercase and there is | at least one cased character in B, False otherwise. | | join(self, iterable_of_bytes, /) | Concatenate any number of bytes objects. | | The bytes whose method is called is inserted in between each pair. | | The result is returned as a new bytes object. | | Example: b'.'.join([b'ab', b'pq', b'rs']) -> b'ab.pq.rs'. | | ljust(self, width, fillchar=b' ', /) | Return a left-justified string of length width. | | Padding is done using the specified fill character. | | lower(...) | B.lower() -> copy of B | | Return a copy of B with all ASCII characters converted to lowercase. | | lstrip(self, bytes=None, /) | Strip leading bytes contained in the argument. | | If the argument is omitted or None, strip leading ASCII whitespace. | | partition(self, sep, /) | Partition the bytes into three parts using the given separator. | | This will search for the separator sep in the bytes. If the separator is found, | returns a 3-tuple containing the part before the separator, the separator | itself, and the part after it. | | If the separator is not found, returns a 3-tuple containing the original bytes | object and two empty bytes objects. | | replace(self, old, new, count=-1, /) | Return a copy with all occurrences of substring old replaced by new. | | count | Maximum number of occurrences to replace. | -1 (the default value) means replace all occurrences. | | If the optional argument count is given, only the first count occurrences are | replaced. | | rfind(...) | B.rfind(sub[, start[, end]]) -> int | | Return the highest index in B where subsection sub is found, | such that sub is contained within B[start,end]. Optional | arguments start and end are interpreted as in slice notation. | | Return -1 on failure. | | rindex(...) | B.rindex(sub[, start[, end]]) -> int | | Return the highest index in B where subsection sub is found, | such that sub is contained within B[start,end]. Optional | arguments start and end are interpreted as in slice notation. | | Raise ValueError when the subsection is not found. | | rjust(self, width, fillchar=b' ', /) | Return a right-justified string of length width. | | Padding is done using the specified fill character. | | rpartition(self, sep, /) | Partition the bytes into three parts using the given separator. | | This will search for the separator sep in the bytes, starting at the end. If | the separator is found, returns a 3-tuple containing the part before the | separator, the separator itself, and the part after it. | | If the separator is not found, returns a 3-tuple containing two empty bytes | objects and the original bytes object. | | rsplit(self, /, sep=None, maxsplit=-1) | Return a list of the sections in the bytes, using sep as the delimiter. | | sep | The delimiter according which to split the bytes. | None (the default value) means split on ASCII whitespace characters | (space, tab, return, newline, formfeed, vertical tab). | maxsplit | Maximum number of splits to do. | -1 (the default value) means no limit. | | Splitting is done starting at the end of the bytes and working to the front. | | rstrip(self, bytes=None, /) | Strip trailing bytes contained in the argument. | | If the argument is omitted or None, strip trailing ASCII whitespace. | | split(self, /, sep=None, maxsplit=-1) | Return a list of the sections in the bytes, using sep as the delimiter. | | sep | The delimiter according which to split the bytes. | None (the default value) means split on ASCII whitespace characters | (space, tab, return, newline, formfeed, vertical tab). | maxsplit | Maximum number of splits to do. | -1 (the default value) means no limit. | | splitlines(self, /, keepends=False) | Return a list of the lines in the bytes, breaking at line boundaries. | | Line breaks are not included in the resulting list unless keepends is given and | true. | | startswith(...) | B.startswith(prefix[, start[, end]]) -> bool | | Return True if B starts with the specified prefix, False otherwise. | With optional start, test B beginning at that position. | With optional end, stop comparing B at that position. | prefix can also be a tuple of bytes to try. | | strip(self, bytes=None, /) | Strip leading and trailing bytes contained in the argument. | | If the argument is omitted or None, strip leading and trailing ASCII whitespace. | | swapcase(...) | B.swapcase() -> copy of B | | Return a copy of B with uppercase ASCII characters converted | to lowercase ASCII and vice versa. | | title(...) | B.title() -> copy of B | | Return a titlecased version of B, i.e. ASCII words start with uppercase | characters, all remaining cased characters have lowercase. | | translate(self, table, /, delete=b'') | Return a copy with each character mapped by the given translation table. | | table | Translation table, which must be a bytes object of length 256. | | All characters occurring in the optional argument delete are removed. | The remaining characters are mapped through the given translation table. | | upper(...) | B.upper() -> copy of B | | Return a copy of B with all ASCII characters converted to uppercase. | | zfill(self, width, /) | Pad a numeric string with zeros on the left, to fill a field of the given width. | | The original string is never truncated. | | ---------------------------------------------------------------------- | Class methods inherited from builtins.bytes: | | fromhex(string, /) from builtins.type | Create a bytes object from a string of hexadecimal numbers. | | Spaces between two numbers are accepted. | Example: bytes.fromhex('B9 01EF') -> b'\\xb9\\x01\\xef'. | | ---------------------------------------------------------------------- | Static methods inherited from builtins.bytes: | | maketrans(frm, to, /) | Return a translation table useable for the bytes or bytearray translate method. | | The returned table will be one where each byte in frm is mapped to the byte at | the same position in to. | | The bytes objects frm and to must be of the same length. | | ---------------------------------------------------------------------- | Methods inherited from generic: | | __abs__(self, /) | abs(self) | | __and__(self, value, /) | Return self&value. | | __array__(...) | sc.__array__(dtype) return 0-dim array from scalar with specified dtype | | __array_wrap__(...) | sc.__array_wrap__(obj) return scalar from array | | __bool__(self, /) | self != 0 | | __copy__(...) | | __deepcopy__(...) | | __divmod__(self, value, /) | Return divmod(self, value). | | __float__(self, /) | float(self) | | __floordiv__(self, value, /) | Return self//value. | | __format__(...) | NumPy array scalar formatter | | __int__(self, /) | int(self) | | __invert__(self, /) | ~self | | __lshift__(self, value, /) | Return self<<value. | | __neg__(self, /) | -self | | __or__(self, value, /) | Return self|value. | | __pos__(self, /) | +self | | __pow__(self, value, mod=None, /) | Return pow(self, value, mod). | | __radd__(self, value, /) | Return value+self. | | __rand__(self, value, /) | Return value&self. | | __rdivmod__(self, value, /) | Return divmod(value, self). | | __reduce__(...) | Helper for pickle. | | __rfloordiv__(self, value, /) | Return value//self. | | __rlshift__(self, value, /) | Return value<<self. | | __ror__(self, value, /) | Return value|self. | | __rpow__(self, value, mod=None, /) | Return pow(value, self, mod). | | __rrshift__(self, value, /) | Return value>>self. | | __rshift__(self, value, /) | Return self>>value. | | __rsub__(self, value, /) | Return value-self. | | __rtruediv__(self, value, /) | Return value/self. | | __rxor__(self, value, /) | Return value^self. | | __setstate__(...) | | __sizeof__(...) | Size of object in memory, in bytes. | | __sub__(self, value, /) | Return self-value. | | __truediv__(self, value, /) | Return self/value. | | __xor__(self, value, /) | Return self^value. | | all(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | getfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | base | base object | | data | pointer to start of data | | dtype | get array data-descriptor | | flags | integer value of flags | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension cdouble = class complex128(complexfloating, builtins.complex) | cdouble(real=0, imag=0) | | Complex number type composed of two double-precision floating-point | numbers, compatible with Python `complex`. | Character code: ``'D'``. | Canonical name: ``np.cdouble``. | Alias: ``np.cfloat``. | Alias: ``np.complex_``. | Alias *on this platform*: ``np.complex128``: Complex number type composed of 2 64-bit-precision floating-point numbers. | | Method resolution order: | complex128 | complexfloating | inexact | number | generic | builtins.complex | builtins.object | | Methods defined here: | | __abs__(self, /) | abs(self) | | __add__(self, value, /) | Return self+value. | | __bool__(self, /) | self != 0 | | __eq__(self, value, /) | Return self==value. | | __float__(self, /) | float(self) | | __floordiv__(self, value, /) | Return self//value. | | __ge__(self, value, /) | Return self>=value. | | __gt__(self, value, /) | Return self>value. | | __hash__(self, /) | Return hash(self). | | __int__(self, /) | int(self) | | __le__(self, value, /) | Return self<=value. | | __lt__(self, value, /) | Return self<value. | | __mul__(self, value, /) | Return self*value. | | __ne__(self, value, /) | Return self!=value. | | __neg__(self, /) | -self | | __pos__(self, /) | +self | | __pow__(self, value, mod=None, /) | Return pow(self, value, mod). | | __radd__(self, value, /) | Return value+self. | | __repr__(self, /) | Return repr(self). | | __rfloordiv__(self, value, /) | Return value//self. | | __rmul__(self, value, /) | Return value*self. | | __rpow__(self, value, mod=None, /) | Return pow(value, self, mod). | | __rsub__(self, value, /) | Return value-self. | | __rtruediv__(self, value, /) | Return value/self. | | __str__(self, /) | Return str(self). | | __sub__(self, value, /) | Return self-value. | | __truediv__(self, value, /) | Return self/value. | | ---------------------------------------------------------------------- | Static methods defined here: | | __new__(*args, **kwargs) from builtins.type | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Methods inherited from complexfloating: | | __round__(...) | | ---------------------------------------------------------------------- | Methods inherited from generic: | | __and__(self, value, /) | Return self&value. | | __array__(...) | sc.__array__(dtype) return 0-dim array from scalar with specified dtype | | __array_wrap__(...) | sc.__array_wrap__(obj) return scalar from array | | __copy__(...) | | __deepcopy__(...) | | __divmod__(self, value, /) | Return divmod(self, value). | | __format__(...) | NumPy array scalar formatter | | __getitem__(self, key, /) | Return self[key]. | | __invert__(self, /) | ~self | | __lshift__(self, value, /) | Return self<<value. | | __mod__(self, value, /) | Return self%value. | | __or__(self, value, /) | Return self|value. | | __rand__(self, value, /) | Return value&self. | | __rdivmod__(self, value, /) | Return divmod(value, self). | | __reduce__(...) | Helper for pickle. | | __rlshift__(self, value, /) | Return value<<self. | | __rmod__(self, value, /) | Return value%self. | | __ror__(self, value, /) | Return value|self. | | __rrshift__(self, value, /) | Return value>>self. | | __rshift__(self, value, /) | Return self>>value. | | __rxor__(self, value, /) | Return value^self. | | __setstate__(...) | | __sizeof__(...) | Size of object in memory, in bytes. | | __xor__(self, value, /) | Return self^value. | | all(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | getfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | base | base object | | data | pointer to start of data | | dtype | get array data-descriptor | | flags | integer value of flags | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension | | ---------------------------------------------------------------------- | Methods inherited from builtins.complex: | | __getattribute__(self, name, /) | Return getattr(self, name). | | __getnewargs__(...) cfloat = class complex128(complexfloating, builtins.complex) | cfloat(real=0, imag=0) | | Complex number type composed of two double-precision floating-point | numbers, compatible with Python `complex`. | Character code: ``'D'``. | Canonical name: ``np.cdouble``. | Alias: ``np.cfloat``. | Alias: ``np.complex_``. | Alias *on this platform*: ``np.complex128``: Complex number type composed of 2 64-bit-precision floating-point numbers. | | Method resolution order: | complex128 | complexfloating | inexact | number | generic | builtins.complex | builtins.object | | Methods defined here: | | __abs__(self, /) | abs(self) | | __add__(self, value, /) | Return self+value. | | __bool__(self, /) | self != 0 | | __eq__(self, value, /) | Return self==value. | | __float__(self, /) | float(self) | | __floordiv__(self, value, /) | Return self//value. | | __ge__(self, value, /) | Return self>=value. | | __gt__(self, value, /) | Return self>value. | | __hash__(self, /) | Return hash(self). | | __int__(self, /) | int(self) | | __le__(self, value, /) | Return self<=value. | | __lt__(self, value, /) | Return self<value. | | __mul__(self, value, /) | Return self*value. | | __ne__(self, value, /) | Return self!=value. | | __neg__(self, /) | -self | | __pos__(self, /) | +self | | __pow__(self, value, mod=None, /) | Return pow(self, value, mod). | | __radd__(self, value, /) | Return value+self. | | __repr__(self, /) | Return repr(self). | | __rfloordiv__(self, value, /) | Return value//self. | | __rmul__(self, value, /) | Return value*self. | | __rpow__(self, value, mod=None, /) | Return pow(value, self, mod). | | __rsub__(self, value, /) | Return value-self. | | __rtruediv__(self, value, /) | Return value/self. | | __str__(self, /) | Return str(self). | | __sub__(self, value, /) | Return self-value. | | __truediv__(self, value, /) | Return self/value. | | ---------------------------------------------------------------------- | Static methods defined here: | | __new__(*args, **kwargs) from builtins.type | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Methods inherited from complexfloating: | | __round__(...) | | ---------------------------------------------------------------------- | Methods inherited from generic: | | __and__(self, value, /) | Return self&value. | | __array__(...) | sc.__array__(dtype) return 0-dim array from scalar with specified dtype | | __array_wrap__(...) | sc.__array_wrap__(obj) return scalar from array | | __copy__(...) | | __deepcopy__(...) | | __divmod__(self, value, /) | Return divmod(self, value). | | __format__(...) | NumPy array scalar formatter | | __getitem__(self, key, /) | Return self[key]. | | __invert__(self, /) | ~self | | __lshift__(self, value, /) | Return self<<value. | | __mod__(self, value, /) | Return self%value. | | __or__(self, value, /) | Return self|value. | | __rand__(self, value, /) | Return value&self. | | __rdivmod__(self, value, /) | Return divmod(value, self). | | __reduce__(...) | Helper for pickle. | | __rlshift__(self, value, /) | Return value<<self. | | __rmod__(self, value, /) | Return value%self. | | __ror__(self, value, /) | Return value|self. | | __rrshift__(self, value, /) | Return value>>self. | | __rshift__(self, value, /) | Return self>>value. | | __rxor__(self, value, /) | Return value^self. | | __setstate__(...) | | __sizeof__(...) | Size of object in memory, in bytes. | | __xor__(self, value, /) | Return self^value. | | all(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | getfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | base | base object | | data | pointer to start of data | | dtype | get array data-descriptor | | flags | integer value of flags | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension | | ---------------------------------------------------------------------- | Methods inherited from builtins.complex: | | __getattribute__(self, name, /) | Return getattr(self, name). | | __getnewargs__(...) class character(flexible) | Abstract base class of all character string scalar types. | | Method resolution order: | character | flexible | generic | builtins.object | | Methods inherited from generic: | | __abs__(self, /) | abs(self) | | __add__(self, value, /) | Return self+value. | | __and__(self, value, /) | Return self&value. | | __array__(...) | sc.__array__(dtype) return 0-dim array from scalar with specified dtype | | __array_wrap__(...) | sc.__array_wrap__(obj) return scalar from array | | __bool__(self, /) | self != 0 | | __copy__(...) | | __deepcopy__(...) | | __divmod__(self, value, /) | Return divmod(self, value). | | __eq__(self, value, /) | Return self==value. | | __float__(self, /) | float(self) | | __floordiv__(self, value, /) | Return self//value. | | __format__(...) | NumPy array scalar formatter | | __ge__(self, value, /) | Return self>=value. | | __getitem__(self, key, /) | Return self[key]. | | __gt__(self, value, /) | Return self>value. | | __int__(self, /) | int(self) | | __invert__(self, /) | ~self | | __le__(self, value, /) | Return self<=value. | | __lshift__(self, value, /) | Return self<<value. | | __lt__(self, value, /) | Return self<value. | | __mod__(self, value, /) | Return self%value. | | __mul__(self, value, /) | Return self*value. | | __ne__(self, value, /) | Return self!=value. | | __neg__(self, /) | -self | | __or__(self, value, /) | Return self|value. | | __pos__(self, /) | +self | | __pow__(self, value, mod=None, /) | Return pow(self, value, mod). | | __radd__(self, value, /) | Return value+self. | | __rand__(self, value, /) | Return value&self. | | __rdivmod__(self, value, /) | Return divmod(value, self). | | __reduce__(...) | Helper for pickle. | | __rfloordiv__(self, value, /) | Return value//self. | | __rlshift__(self, value, /) | Return value<<self. | | __rmod__(self, value, /) | Return value%self. | | __rmul__(self, value, /) | Return value*self. | | __ror__(self, value, /) | Return value|self. | | __rpow__(self, value, mod=None, /) | Return pow(value, self, mod). | | __rrshift__(self, value, /) | Return value>>self. | | __rshift__(self, value, /) | Return self>>value. | | __rsub__(self, value, /) | Return value-self. | | __rtruediv__(self, value, /) | Return value/self. | | __rxor__(self, value, /) | Return value^self. | | __setstate__(...) | | __sizeof__(...) | Size of object in memory, in bytes. | | __sub__(self, value, /) | Return self-value. | | __truediv__(self, value, /) | Return self/value. | | __xor__(self, value, /) | Return self^value. | | all(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | getfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | base | base object | | data | pointer to start of data | | dtype | get array data-descriptor | | flags | integer value of flags | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension | | ---------------------------------------------------------------------- | Data and other attributes inherited from generic: | | __hash__ = None class chararray(ndarray) | chararray(shape, itemsize=1, unicode=False, buffer=None, offset=0, strides=None, order='C') | | 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='F'``, 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 : object exposing the buffer interface or str, 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([[b'a', b'a', b'a'], | [b'a', b'a', b'a'], | [b'a', b'a', b'a']], dtype='|S1') | | >>> charar = np.chararray(charar.shape, itemsize=5) | >>> charar[:] = 'abc' | >>> charar | chararray([[b'abc', b'abc', b'abc'], | [b'abc', b'abc', b'abc'], | [b'abc', b'abc', b'abc']], dtype='|S5') | | Method resolution order: | chararray | ndarray | builtins.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) | None. | | __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) | Return self[key]. | | __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 | (interpolation), 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) | Return value%self. | | __rmul__(self, i) | Return (self * i), that is string multiple concatenation, | element-wise. | | See also | -------- | multiply | | argsort(self, axis=-1, kind=None, order=None) | a.argsort(axis=-1, kind=None, 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') | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Data descriptors defined here: | | __dict__ | dictionary for instance variables (if defined) | | ---------------------------------------------------------------------- | Data and other attributes defined here: | | __hash__ = None | | ---------------------------------------------------------------------- | Methods inherited from ndarray: | | __abs__(self, /) | abs(self) | | __and__(self, value, /) | Return self&value. | | __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_function__(...) | | __array_prepare__(...) | a.__array_prepare__(obj) -> Object of same type as ndarray object obj. | | __array_ufunc__(...) | | __array_wrap__(...) | a.__array_wrap__(obj) -> Object of same type as ndarray object a. | | __bool__(self, /) | self != 0 | | __complex__(...) | | __contains__(self, key, /) | Return key in self. | | __copy__(...) | a.__copy__() | | Used if :func:`copy.copy` is called on an array. Returns a copy of the array. | | Equivalent to ``a.copy(order='K')``. | | __deepcopy__(...) | a.__deepcopy__(memo, /) -> Deep copy of array. | | Used if :func:`copy.deepcopy` is called on an array. | | __delitem__(self, key, /) | Delete self[key]. | | __divmod__(self, value, /) | Return divmod(self, value). | | __float__(self, /) | float(self) | | __floordiv__(self, value, /) | Return self//value. | | __format__(...) | Default object formatter. | | __iadd__(self, value, /) | Return self+=value. | | __iand__(self, value, /) | Return self&=value. | | __ifloordiv__(self, value, /) | Return self//=value. | | __ilshift__(self, value, /) | Return self<<=value. | | __imatmul__(self, value, /) | Return self@=value. | | __imod__(self, value, /) | Return self%=value. | | __imul__(self, value, /) | Return self*=value. | | __index__(self, /) | Return self converted to an integer, if self is suitable for use as an index into a list. | | __int__(self, /) | int(self) | | __invert__(self, /) | ~self | | __ior__(self, value, /) | Return self|=value. | | __ipow__(self, value, /) | Return self**=value. | | __irshift__(self, value, /) | Return self>>=value. | | __isub__(self, value, /) | Return self-=value. | | __iter__(self, /) | Implement iter(self). | | __itruediv__(self, value, /) | Return self/=value. | | __ixor__(self, value, /) | Return self^=value. | | __len__(self, /) | Return len(self). | | __lshift__(self, value, /) | Return self<<value. | | __matmul__(self, value, /) | Return self@value. | | __neg__(self, /) | -self | | __or__(self, value, /) | Return self|value. | | __pos__(self, /) | +self | | __pow__(self, value, mod=None, /) | Return pow(self, value, mod). | | __rand__(self, value, /) | Return value&self. | | __rdivmod__(self, value, /) | Return divmod(value, self). | | __reduce__(...) | a.__reduce__() | | For pickling. | | __reduce_ex__(...) | Helper for pickle. | | __repr__(self, /) | Return repr(self). | | __rfloordiv__(self, value, /) | Return value//self. | | __rlshift__(self, value, /) | Return value<<self. | | __rmatmul__(self, value, /) | Return value@self. | | __ror__(self, value, /) | Return value|self. | | __rpow__(self, value, mod=None, /) | Return pow(value, self, mod). | | __rrshift__(self, value, /) | Return value>>self. | | __rshift__(self, value, /) | Return self>>value. | | __rsub__(self, value, /) | Return value-self. | | __rtruediv__(self, value, /) | Return value/self. | | __rxor__(self, value, /) | Return value^self. | | __setitem__(self, key, value, /) | Set self[key] to value. | | __setstate__(...) | a.__setstate__(state, /) | | For unpickling. | | The `state` argument must be a sequence that contains the following | elements: | | Parameters | ---------- | version : int | optional pickle version. If omitted defaults to 0. | shape : tuple | dtype : data-type | isFortran : bool | rawdata : string or list | a binary string with the data (or a list if 'a' is an object array) | | __sizeof__(...) | Size of object in memory, in bytes. | | __str__(self, /) | Return str(self). | | __sub__(self, value, /) | Return self-value. | | __truediv__(self, value, /) | Return self/value. | | __xor__(self, value, /) | Return self^value. | | all(...) | a.all(axis=None, out=None, keepdims=False) | | Returns True if all elements evaluate to True. | | Refer to `numpy.all` for full documentation. | | See Also | -------- | numpy.all : equivalent function | | any(...) | a.any(axis=None, out=None, keepdims=False) | | Returns True if any of the elements of `a` evaluate to True. | | Refer to `numpy.any` for full documentation. | | See Also | -------- | numpy.any : equivalent function | | argmax(...) | a.argmax(axis=None, out=None) | | Return indices of the maximum values along the given axis. | | Refer to `numpy.argmax` for full documentation. | | See Also | -------- | numpy.argmax : equivalent function | | argmin(...) | a.argmin(axis=None, out=None) | | Return indices of the minimum values along the given axis of `a`. | | Refer to `numpy.argmin` for detailed documentation. | | See Also | -------- | numpy.argmin : equivalent function | | argpartition(...) | a.argpartition(kth, axis=-1, kind='introselect', order=None) | | Returns the indices that would partition this array. | | Refer to `numpy.argpartition` for full documentation. | | .. versionadded:: 1.8.0 | | See Also | -------- | numpy.argpartition : equivalent function | | 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 parameter), `arr_t` | is a new array of the same shape as the input array, with dtype, order | given by `dtype`, `order`. | | Notes | ----- | .. versionchanged:: 1.17.0 | Casting between a simple data type and a structured one is possible only | for "unsafe" casting. Casting to multiple fields is allowed, but | casting from multiple fields is not. | | .. versionchanged:: 1.9.0 | Casting from numeric to string types in 'safe' casting mode requires | that the string dtype length is long enough to store the max | integer/float value converted. | | 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=False) | | 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. | Arrays of byte-strings are not swapped. The real and imaginary | parts of a complex number are swapped individually. | | 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) | >>> list(map(hex, A)) | ['0x1', '0x100', '0x2233'] | >>> A.byteswap(inplace=True) | array([ 256, 1, 13090], dtype=int16) | >>> list(map(hex, A)) | ['0x100', '0x1', '0x3322'] | | Arrays of byte-strings are not swapped | | >>> A = np.array([b'ceg', b'fac']) | >>> A.byteswap() | array([b'ceg', b'fac'], dtype='|S3') | | ``A.newbyteorder().byteswap()`` produces an array with the same values | but different representation in memory | | >>> A = np.array([1, 2, 3]) | >>> A.view(np.uint8) | array([1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, | 0, 0], dtype=uint8) | >>> A.newbyteorder().byteswap(inplace=True) | array([1, 2, 3]) | >>> A.view(np.uint8) | array([0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, | 0, 3], dtype=uint8) | | choose(...) | a.choose(choices, out=None, mode='raise') | | Use an index array to construct a new array from a set of choices. | | Refer to `numpy.choose` for full documentation. | | See Also | -------- | numpy.choose : equivalent function | | clip(...) | a.clip(min=None, max=None, out=None, **kwargs) | | Return an array whose values are limited to ``[min, max]``. | One of max or min must be given. | | Refer to `numpy.clip` for full documentation. | | See Also | -------- | numpy.clip : equivalent function | | compress(...) | a.compress(condition, axis=None, out=None) | | Return selected slices of this array along given axis. | | Refer to `numpy.compress` for full documentation. | | See Also | -------- | numpy.compress : equivalent function | | conj(...) | a.conj() | | Complex-conjugate all elements. | | Refer to `numpy.conjugate` for full documentation. | | See Also | -------- | numpy.conjugate : equivalent function | | conjugate(...) | a.conjugate() | | Return the complex conjugate, element-wise. | | Refer to `numpy.conjugate` for full documentation. | | See Also | -------- | numpy.conjugate : equivalent function | | copy(...) | a.copy(order='C') | | Return a copy of the array. | | Parameters | ---------- | order : {'C', 'F', 'A', 'K'}, optional | Controls the memory layout of the copy. 'C' means C-order, | 'F' means F-order, 'A' means 'F' if `a` is Fortran contiguous, | 'C' otherwise. 'K' means match the layout of `a` as closely | as possible. (Note that this function and :func:`numpy.copy` are very | similar, but have different default values for their order= | arguments.) | | See also | -------- | numpy.copy | numpy.copyto | | Examples | -------- | >>> x = np.array([[1,2,3],[4,5,6]], order='F') | | >>> y = x.copy() | | >>> x.fill(0) | | >>> x | array([[0, 0, 0], | [0, 0, 0]]) | | >>> y | array([[1, 2, 3], | [4, 5, 6]]) | | >>> y.flags['C_CONTIGUOUS'] | True | | cumprod(...) | a.cumprod(axis=None, dtype=None, out=None) | | Return the cumulative product of the elements along the given axis. | | Refer to `numpy.cumprod` for full documentation. | | See Also | -------- | numpy.cumprod : equivalent function | | cumsum(...) | a.cumsum(axis=None, dtype=None, out=None) | | Return the cumulative sum of the elements along the given axis. | | Refer to `numpy.cumsum` for full documentation. | | See Also | -------- | numpy.cumsum : equivalent function | | diagonal(...) | a.diagonal(offset=0, axis1=0, axis2=1) | | Return specified diagonals. In NumPy 1.9 the returned array is a | read-only view instead of a copy as in previous NumPy versions. In | a future version the read-only restriction will be removed. | | Refer to :func:`numpy.diagonal` for full documentation. | | See Also | -------- | numpy.diagonal : equivalent function | | dot(...) | a.dot(b, out=None) | | Dot product of two arrays. | | Refer to `numpy.dot` for full documentation. | | See Also | -------- | numpy.dot : equivalent function | | Examples | -------- | >>> a = np.eye(2) | >>> b = np.ones((2, 2)) * 2 | >>> a.dot(b) | array([[2., 2.], | [2., 2.]]) | | This array method can be conveniently chained: | | >>> a.dot(b).dot(b) | array([[8., 8.], | [8., 8.]]) | | dump(...) | a.dump(file) | | Dump a pickle of the array to the specified file. | The array can be read back with pickle.load or numpy.load. | | Parameters | ---------- | file : str or Path | A string naming the dump file. | | .. versionchanged:: 1.17.0 | `pathlib.Path` objects are now accepted. | | 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', 'K'}, optional | 'C' means to flatten in row-major (C-style) order. | 'F' means to flatten in column-major (Fortran- | style) order. 'A' means to flatten in column-major | order if `a` is Fortran *contiguous* in memory, | row-major order otherwise. 'K' means to flatten | `a` in the order the elements occur in memory. | The default is 'C'. | | Returns | ------- | y : ndarray | A copy of the input array, flattened to one dimension. | | See Also | -------- | ravel : Return a flattened array. | flat : A 1-D flat iterator over the array. | | Examples | -------- | >>> a = np.array([[1,2], [3,4]]) | >>> a.flatten() | array([1, 2, 3, 4]) | >>> a.flatten('F') | array([1, 3, 2, 4]) | | getfield(...) | a.getfield(dtype, offset=0) | | Returns a field of the given array as a certain type. | | A field is a view of the array data with a given data-type. The values in | the view are determined by the given type and the offset into the current | array in bytes. The offset needs to be such that the view dtype fits in the | array dtype; for example an array of dtype complex128 has 16-byte elements. | If taking a view with a 32-bit integer (4 bytes), the offset needs to be | between 0 and 12 bytes. | | Parameters | ---------- | dtype : str or dtype | The data type of the view. The dtype size of the view can not be larger | than that of the array itself. | offset : int | Number of bytes to skip before beginning the element view. | | Examples | -------- | >>> x = np.diag([1.+1.j]*2) | >>> x[1, 1] = 2 + 4.j | >>> x | array([[1.+1.j, 0.+0.j], | [0.+0.j, 2.+4.j]]) | >>> x.getfield(np.float64) | array([[1., 0.], | [0., 2.]]) | | By choosing an offset of 8 bytes we can select the complex part of the | array for our view: | | >>> x.getfield(np.float64, offset=8) | array([[1., 0.], | [0., 4.]]) | | item(...) | a.item(*args) | | Copy an element of an array to a standard Python scalar and return it. | | Parameters | ---------- | \*args : Arguments (variable number and type) | | * none: in this case, the method only works for arrays | with one element (`a.size == 1`), which element is | copied into a standard Python scalar object and returned. | | * int_type: this argument is interpreted as a flat index into | the array, specifying which element to copy and return. | | * tuple of int_types: functions as does a single int_type argument, | except that the argument is interpreted as an nd-index into the | array. | | Returns | ------- | z : Standard Python scalar object | A copy of the specified element of the array as a suitable | Python scalar | | Notes | ----- | When the data type of `a` is longdouble or clongdouble, item() returns | a scalar array object because there is no available Python scalar that | would not lose information. Void arrays return a buffer object for item(), | unless fields are defined, in which case a tuple is returned. | | `item` is very similar to a[args], except, instead of an array scalar, | a standard Python scalar is returned. This can be useful for speeding up | access to elements of the array and doing arithmetic on elements of the | array using Python's optimized math. | | Examples | -------- | >>> np.random.seed(123) | >>> x = np.random.randint(9, size=(3, 3)) | >>> x | array([[2, 2, 6], | [1, 3, 6], | [1, 0, 1]]) | >>> x.item(3) | 1 | >>> x.item(7) | 0 | >>> x.item((0, 1)) | 2 | >>> x.item((2, 2)) | 1 | | 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 | -------- | >>> np.random.seed(123) | >>> x = np.random.randint(9, size=(3, 3)) | >>> x | array([[2, 2, 6], | [1, 3, 6], | [1, 0, 1]]) | >>> x.itemset(4, 0) | >>> x.itemset((2, 2), 9) | >>> x | array([[2, 2, 6], | [1, 0, 6], | [1, 0, 9]]) | | max(...) | a.max(axis=None, out=None, keepdims=False, initial=<no value>, where=True) | | Return the maximum along a given axis. | | Refer to `numpy.amax` for full documentation. | | See Also | -------- | numpy.amax : equivalent function | | mean(...) | a.mean(axis=None, dtype=None, out=None, keepdims=False) | | Returns the average of the array elements along given axis. | | Refer to `numpy.mean` for full documentation. | | See Also | -------- | numpy.mean : equivalent function | | min(...) | a.min(axis=None, out=None, keepdims=False, initial=<no value>, where=True) | | Return the minimum along a given axis. | | Refer to `numpy.amin` for full documentation. | | See Also | -------- | numpy.amin : equivalent function | | newbyteorder(...) | arr.newbyteorder(new_order='S') | | Return the array with the same data viewed with a different byte order. | | Equivalent to:: | | arr.view(arr.dtype.newbytorder(new_order)) | | Changes are also made in all fields and sub-arrays of the array data | type. | | | | Parameters | ---------- | new_order : string, optional | Byte order to force; a value from the byte order specifications | below. `new_order` codes can be any of: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_arr : array | New array object with the dtype reflecting given change to the | byte order. | | nonzero(...) | a.nonzero() | | Return the indices of the elements that are non-zero. | | Refer to `numpy.nonzero` for full documentation. | | See Also | -------- | numpy.nonzero : equivalent function | | prod(...) | a.prod(axis=None, dtype=None, out=None, keepdims=False, initial=1, where=True) | | 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, keepdims=False) | | 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 | | Notes | ----- | Unlike the free function `numpy.reshape`, this method on `ndarray` allows | the elements of the shape parameter to be passed in as separate arguments. | For example, ``a.reshape(10, 11)`` is equivalent to | ``a.reshape((10, 11))``. | | 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. | PyPy only: will always raise if the data memory must be changed, since | there is no reliable way to determine if references or views to it | exist. | | 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 references or is 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]], dtype=int32) | >>> x | array([[1.0e+000, 1.5e-323, 1.5e-323], | [1.5e-323, 1.0e+000, 1.5e-323], | [1.5e-323, 1.5e-323, 1.0e+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, (WRITEBACKIFCOPY 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 WRITEBACKIFCOPY and (deprecated) UPDATEIFCOPY flags 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 7 Boolean flags | in use, only four of which can be changed by the user: | WRITEBACKIFCOPY, 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) (deprecated), replaced by WRITEBACKIFCOPY; | | WRITEBACKIFCOPY (X) this array is a copy of some other array (referenced | by .base). When the C-API function PyArray_ResolveWritebackIfCopy is | called, the base array will be updated with the contents of this array. | | All flags can be accessed using the single (upper case) letter as well | as the full name. | | Examples | -------- | >>> y = np.array([[3, 1, 7], | ... [2, 0, 0], | ... [8, 5, 9]]) | >>> 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 | WRITEBACKIFCOPY : False | UPDATEIFCOPY : False | >>> y.setflags(write=0, align=0) | >>> y.flags | C_CONTIGUOUS : True | F_CONTIGUOUS : False | OWNDATA : True | WRITEABLE : False | ALIGNED : False | WRITEBACKIFCOPY : False | UPDATEIFCOPY : False | >>> y.setflags(uic=1) | Traceback (most recent call last): | File "<stdin>", line 1, in <module> | ValueError: cannot set WRITEBACKIFCOPY flag to True | | sort(...) | a.sort(axis=-1, kind=None, order=None) | | Sort an array in-place. Refer to `numpy.sort` for full documentation. | | Parameters | ---------- | axis : int, optional | Axis along which to sort. Default is -1, which means sort along the | last axis. | kind : {'quicksort', 'mergesort', 'heapsort', 'stable'}, optional | Sorting algorithm. The default is 'quicksort'. Note that both 'stable' | and 'mergesort' use timsort under the covers and, in general, the | actual implementation will vary with datatype. The 'mergesort' option | is retained for backwards compatibility. | | .. versionchanged:: 1.15.0. | The 'stable' option was added. | | order : str or list of str, optional | When `a` is an array with fields defined, this argument specifies | which fields to compare first, second, etc. A single field can | be specified as a string, and not all fields need be specified, | but unspecified fields will still be used, in the order in which | they come up in the dtype, to break ties. | | See Also | -------- | numpy.sort : Return a sorted copy of an array. | numpy.argsort : Indirect sort. | numpy.lexsort : Indirect stable sort on multiple keys. | numpy.searchsorted : Find elements in sorted array. | numpy.partition: Partial sort. | | Notes | ----- | See `numpy.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([(b'c', 1), (b'a', 2)], | dtype=[('x', 'S1'), ('y', '<i8')]) | | squeeze(...) | a.squeeze(axis=None) | | Remove single-dimensional entries from the shape of `a`. | | Refer to `numpy.squeeze` for full documentation. | | See Also | -------- | numpy.squeeze : equivalent function | | std(...) | a.std(axis=None, dtype=None, out=None, ddof=0, keepdims=False) | | Returns the standard deviation of the array elements along given axis. | | Refer to `numpy.std` for full documentation. | | See Also | -------- | numpy.std : equivalent function | | sum(...) | a.sum(axis=None, dtype=None, out=None, keepdims=False, initial=0, where=True) | | Return the sum of the array elements over the given axis. | | Refer to `numpy.sum` for full documentation. | | See Also | -------- | numpy.sum : equivalent function | | swapaxes(...) | a.swapaxes(axis1, axis2) | | Return a view of the array with `axis1` and `axis2` interchanged. | | Refer to `numpy.swapaxes` for full documentation. | | See Also | -------- | numpy.swapaxes : equivalent function | | take(...) | a.take(indices, axis=None, out=None, mode='raise') | | Return an array formed from the elements of `a` at the given indices. | | Refer to `numpy.take` for full documentation. | | See Also | -------- | numpy.take : equivalent function | | tobytes(...) | a.tobytes(order='C') | | Construct Python bytes containing the raw data bytes in the array. | | Constructs Python bytes showing a copy of the raw contents of | data memory. The bytes object can be produced in either 'C' or 'Fortran', | or 'Any' order (the default is 'C'-order). 'Any' order means C-order | unless the F_CONTIGUOUS flag in the array is set, in which case it | means 'Fortran' order. | | .. versionadded:: 1.9.0 | | Parameters | ---------- | order : {'C', 'F', None}, optional | Order of the data for multidimensional arrays: | C, Fortran, or the same as for the original array. | | Returns | ------- | s : bytes | Python bytes exhibiting a copy of `a`'s raw data. | | Examples | -------- | >>> x = np.array([[0, 1], [2, 3]], dtype='<u2') | >>> x.tobytes() | b'\x00\x00\x01\x00\x02\x00\x03\x00' | >>> x.tobytes('C') == x.tobytes() | True | >>> x.tobytes('F') | b'\x00\x00\x02\x00\x01\x00\x03\x00' | | tofile(...) | a.tofile(fid, sep="", format="%s") | | Write array to a file as text or binary (default). | | Data is always written in 'C' order, independent of the order of `a`. | The data produced by this method can be recovered using the function | fromfile(). | | Parameters | ---------- | fid : file or str or Path | An open file object, or a string containing a filename. | | .. versionchanged:: 1.17.0 | `pathlib.Path` objects are now accepted. | | sep : str | Separator between array items for text output. | If "" (empty), a binary file is written, equivalent to | ``file.write(a.tobytes())``. | format : str | Format string for text file output. | Each entry in the array is formatted to text by first converting | it to the closest Python type, and then using "format" % item. | | Notes | ----- | This is a convenience function for quick storage of array data. | Information on endianness and precision is lost, so this method is not a | good choice for files intended to archive data or transport data between | machines with different endianness. Some of these problems can be overcome | by outputting the data as text files, at the expense of speed and file | size. | | When fid is a file object, array contents are directly written to the | file, bypassing the file object's ``write`` method. As a result, tofile | cannot be used with files objects supporting compression (e.g., GzipFile) | or file-like objects that do not support ``fileno()`` (e.g., BytesIO). | | tolist(...) | a.tolist() | | Return the array as an ``a.ndim``-levels deep nested list of Python scalars. | | Return a copy of the array data as a (nested) Python list. | Data items are converted to the nearest compatible builtin Python type, via | the `~numpy.ndarray.item` function. | | If ``a.ndim`` is 0, then since the depth of the nested list is 0, it will | not be a list at all, but a simple Python scalar. | | Parameters | ---------- | none | | Returns | ------- | y : object, or list of object, or list of list of object, or ... | The possibly nested list of array elements. | | Notes | ----- | The array may be recreated via ``a = np.array(a.tolist())``, although this | may sometimes lose precision. | | Examples | -------- | For a 1D array, ``a.tolist()`` is almost the same as ``list(a)``, | except that ``tolist`` changes numpy scalars to Python scalars: | | >>> a = np.uint32([1, 2]) | >>> a_list = list(a) | >>> a_list | [1, 2] | >>> type(a_list[0]) | <class 'numpy.uint32'> | >>> a_tolist = a.tolist() | >>> a_tolist | [1, 2] | >>> type(a_tolist[0]) | <class 'int'> | | Additionally, for a 2D array, ``tolist`` applies recursively: | | >>> a = np.array([[1, 2], [3, 4]]) | >>> list(a) | [array([1, 2]), array([3, 4])] | >>> a.tolist() | [[1, 2], [3, 4]] | | The base case for this recursion is a 0D array: | | >>> a = np.array(1) | >>> list(a) | Traceback (most recent call last): | ... | TypeError: iteration over a 0-d array | >>> a.tolist() | 1 | | tostring(...) | a.tostring(order='C') | | A compatibility alias for `tobytes`, with exactly the same behavior. | | Despite its name, it returns `bytes` not `str`\ s. | | .. deprecated:: 1.19.0 | | 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, as a transposed vector is simply the | same vector. To convert a 1-D array into a 2D column vector, an additional | dimension must be added. `np.atleast2d(a).T` achieves this, as does | `a[:, np.newaxis]`. | For a 2-D array, this is a standard 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. | ndarray.reshape : Give a new shape to an array without changing its data. | | Examples | -------- | >>> a = np.array([[1, 2], [3, 4]]) | >>> a | array([[1, 2], | [3, 4]]) | >>> a.transpose() | array([[1, 3], | [2, 4]]) | >>> a.transpose((1, 0)) | array([[1, 3], | [2, 4]]) | >>> a.transpose(1, 0) | array([[1, 3], | [2, 4]]) | | var(...) | a.var(axis=None, dtype=None, out=None, ddof=0, keepdims=False) | | Returns the variance of the array elements, along given axis. | | Refer to `numpy.var` for full documentation. | | See Also | -------- | numpy.var : equivalent function | | view(...) | a.view([dtype][, type]) | | New view of array with the same data. | | .. note:: | Passing None for ``dtype`` is different from omitting the parameter, | since the former invokes ``dtype(None)`` which is an alias for | ``dtype('float_')``. | | Parameters | ---------- | dtype : data-type or ndarray sub-class, optional | Data-type descriptor of the returned view, e.g., float32 or int16. | Omitting it 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, omission | of the parameter 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.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 | >>> x | array([(1, 20), (3, 4)], dtype=[('a', 'i1'), ('b', 'i1')]) | | Using a view to convert an array to a recarray: | | >>> z = x.view(np.recarray) | >>> z.a | array([1, 3], 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): | ... | ValueError: To change to a dtype of a different size, the array must be C-contiguous | >>> z = y.copy() | >>> z.view(dtype=[('width', np.int16), ('length', np.int16)]) | array([[(1, 2)], | [(4, 5)]], dtype=[('width', '<i2'), ('length', '<i2')]) | | ---------------------------------------------------------------------- | Data descriptors inherited from ndarray: | | T | The transposed array. | | Same as ``self.transpose()``. | | 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.]) | | See Also | -------- | transpose | | __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): | | .. autoattribute:: numpy.core._internal._ctypes.data | :noindex: | | .. autoattribute:: numpy.core._internal._ctypes.shape | :noindex: | | .. autoattribute:: numpy.core._internal._ctypes.strides | :noindex: | | .. automethod:: numpy.core._internal._ctypes.data_as | :noindex: | | .. automethod:: numpy.core._internal._ctypes.shape_as | :noindex: | | .. automethod:: numpy.core._internal._ctypes.strides_as | :noindex: | | 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 = np.array([[0, 1], [2, 3]], dtype=np.int32) | >>> x | array([[0, 1], | [2, 3]], dtype=int32) | >>> x.ctypes.data | 31962608 # may vary | >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_uint32)) | <__main__.LP_c_uint object at 0x7ff2fc1fc200> # may vary | >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_uint32)).contents | c_uint(0) | >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_uint64)).contents | c_ulong(4294967296) | >>> x.ctypes.shape | <numpy.core._internal.c_long_Array_2 object at 0x7ff2fc1fce60> # may vary | >>> x.ctypes.strides | <numpy.core._internal.c_long_Array_2 object at 0x7ff2fc1ff320> # may vary | | 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. | WRITEBACKIFCOPY (X) | This array is a copy of some other array. The C-API function | PyArray_ResolveWritebackIfCopy must be called before deallocating | to the base array will be updated with the contents of this array. | UPDATEIFCOPY (U) | (Deprecated, use WRITEBACKIFCOPY) 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 WRITEBACKIFCOPY, 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``. | - WRITEBACKIFCOPY 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) | <class '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. | | The shape property is usually used to get the current shape of an array, | but may also be used to reshape the array in-place by assigning a tuple of | array dimensions to it. As with `numpy.reshape`, one of the new shape | dimensions can be -1, in which case its value is inferred from the size of | the array and the remaining dimensions. Reshaping an array in-place will | fail if a copy is required. | | 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 | >>> np.zeros((4,2))[::2].shape = (-1,) | Traceback (most recent call last): | File "<stdin>", line 1, in <module> | AttributeError: Incompatible shape for in-place modification. Use | `.reshape()` to make a copy with the desired shape. | | See Also | -------- | numpy.reshape : similar function | ndarray.reshape : similar method | | size | Number of elements in the array. | | Equal to ``np.prod(a.shape)``, i.e., the product of the array's | dimensions. | | Notes | ----- | `a.size` returns a standard arbitrary precision Python integer. This | may not be the case with other methods of obtaining the same value | (like the suggested ``np.prod(a.shape)``, which returns an instance | of ``np.int_``), and may be relevant if the value is used further in | calculations that may overflow a fixed size integer type. | | 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) | Complex number type composed of two extended-precision floating-point | numbers. | Character code: ``'G'``. | Canonical name: ``np.clongdouble``. | Alias: ``np.clongfloat``. | Alias: ``np.longcomplex``. | Alias *on this platform*: ``np.complex256``: Complex number type composed of 2 128-bit extended-precision floating-point numbers. | | Method resolution order: | complex256 | complexfloating | inexact | number | generic | builtins.object | | Methods defined here: | | __abs__(self, /) | abs(self) | | __add__(self, value, /) | Return self+value. | | __bool__(self, /) | self != 0 | | __complex__(...) | | __eq__(self, value, /) | Return self==value. | | __float__(self, /) | float(self) | | __floordiv__(self, value, /) | Return self//value. | | __ge__(self, value, /) | Return self>=value. | | __gt__(self, value, /) | Return self>value. | | __hash__(self, /) | Return hash(self). | | __int__(self, /) | int(self) | | __le__(self, value, /) | Return self<=value. | | __lt__(self, value, /) | Return self<value. | | __mul__(self, value, /) | Return self*value. | | __ne__(self, value, /) | Return self!=value. | | __neg__(self, /) | -self | | __pos__(self, /) | +self | | __pow__(self, value, mod=None, /) | Return pow(self, value, mod). | | __radd__(self, value, /) | Return value+self. | | __repr__(self, /) | Return repr(self). | | __rfloordiv__(self, value, /) | Return value//self. | | __rmul__(self, value, /) | Return value*self. | | __rpow__(self, value, mod=None, /) | Return pow(value, self, mod). | | __rsub__(self, value, /) | Return value-self. | | __rtruediv__(self, value, /) | Return value/self. | | __str__(self, /) | Return str(self). | | __sub__(self, value, /) | Return self-value. | | __truediv__(self, value, /) | Return self/value. | | ---------------------------------------------------------------------- | Static methods defined here: | | __new__(*args, **kwargs) from builtins.type | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Methods inherited from complexfloating: | | __round__(...) | | ---------------------------------------------------------------------- | Methods inherited from generic: | | __and__(self, value, /) | Return self&value. | | __array__(...) | sc.__array__(dtype) return 0-dim array from scalar with specified dtype | | __array_wrap__(...) | sc.__array_wrap__(obj) return scalar from array | | __copy__(...) | | __deepcopy__(...) | | __divmod__(self, value, /) | Return divmod(self, value). | | __format__(...) | NumPy array scalar formatter | | __getitem__(self, key, /) | Return self[key]. | | __invert__(self, /) | ~self | | __lshift__(self, value, /) | Return self<<value. | | __mod__(self, value, /) | Return self%value. | | __or__(self, value, /) | Return self|value. | | __rand__(self, value, /) | Return value&self. | | __rdivmod__(self, value, /) | Return divmod(value, self). | | __reduce__(...) | Helper for pickle. | | __rlshift__(self, value, /) | Return value<<self. | | __rmod__(self, value, /) | Return value%self. | | __ror__(self, value, /) | Return value|self. | | __rrshift__(self, value, /) | Return value>>self. | | __rshift__(self, value, /) | Return self>>value. | | __rxor__(self, value, /) | Return value^self. | | __setstate__(...) | | __sizeof__(...) | Size of object in memory, in bytes. | | __xor__(self, value, /) | Return self^value. | | all(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | getfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | base | base object | | data | pointer to start of data | | dtype | get array data-descriptor | | flags | integer value of flags | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension clongfloat = class complex256(complexfloating) | Complex number type composed of two extended-precision floating-point | numbers. | Character code: ``'G'``. | Canonical name: ``np.clongdouble``. | Alias: ``np.clongfloat``. | Alias: ``np.longcomplex``. | Alias *on this platform*: ``np.complex256``: Complex number type composed of 2 128-bit extended-precision floating-point numbers. | | Method resolution order: | complex256 | complexfloating | inexact | number | generic | builtins.object | | Methods defined here: | | __abs__(self, /) | abs(self) | | __add__(self, value, /) | Return self+value. | | __bool__(self, /) | self != 0 | | __complex__(...) | | __eq__(self, value, /) | Return self==value. | | __float__(self, /) | float(self) | | __floordiv__(self, value, /) | Return self//value. | | __ge__(self, value, /) | Return self>=value. | | __gt__(self, value, /) | Return self>value. | | __hash__(self, /) | Return hash(self). | | __int__(self, /) | int(self) | | __le__(self, value, /) | Return self<=value. | | __lt__(self, value, /) | Return self<value. | | __mul__(self, value, /) | Return self*value. | | __ne__(self, value, /) | Return self!=value. | | __neg__(self, /) | -self | | __pos__(self, /) | +self | | __pow__(self, value, mod=None, /) | Return pow(self, value, mod). | | __radd__(self, value, /) | Return value+self. | | __repr__(self, /) | Return repr(self). | | __rfloordiv__(self, value, /) | Return value//self. | | __rmul__(self, value, /) | Return value*self. | | __rpow__(self, value, mod=None, /) | Return pow(value, self, mod). | | __rsub__(self, value, /) | Return value-self. | | __rtruediv__(self, value, /) | Return value/self. | | __str__(self, /) | Return str(self). | | __sub__(self, value, /) | Return self-value. | | __truediv__(self, value, /) | Return self/value. | | ---------------------------------------------------------------------- | Static methods defined here: | | __new__(*args, **kwargs) from builtins.type | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Methods inherited from complexfloating: | | __round__(...) | | ---------------------------------------------------------------------- | Methods inherited from generic: | | __and__(self, value, /) | Return self&value. | | __array__(...) | sc.__array__(dtype) return 0-dim array from scalar with specified dtype | | __array_wrap__(...) | sc.__array_wrap__(obj) return scalar from array | | __copy__(...) | | __deepcopy__(...) | | __divmod__(self, value, /) | Return divmod(self, value). | | __format__(...) | NumPy array scalar formatter | | __getitem__(self, key, /) | Return self[key]. | | __invert__(self, /) | ~self | | __lshift__(self, value, /) | Return self<<value. | | __mod__(self, value, /) | Return self%value. | | __or__(self, value, /) | Return self|value. | | __rand__(self, value, /) | Return value&self. | | __rdivmod__(self, value, /) | Return divmod(value, self). | | __reduce__(...) | Helper for pickle. | | __rlshift__(self, value, /) | Return value<<self. | | __rmod__(self, value, /) | Return value%self. | | __ror__(self, value, /) | Return value|self. | | __rrshift__(self, value, /) | Return value>>self. | | __rshift__(self, value, /) | Return self>>value. | | __rxor__(self, value, /) | Return value^self. | | __setstate__(...) | | __sizeof__(...) | Size of object in memory, in bytes. | | __xor__(self, value, /) | Return self^value. | | all(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | getfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | base | base object | | data | pointer to start of data | | dtype | get array data-descriptor | | flags | integer value of flags | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension class complex128(complexfloating, builtins.complex) | complex128(real=0, imag=0) | | Complex number type composed of two double-precision floating-point | numbers, compatible with Python `complex`. | Character code: ``'D'``. | Canonical name: ``np.cdouble``. | Alias: ``np.cfloat``. | Alias: ``np.complex_``. | Alias *on this platform*: ``np.complex128``: Complex number type composed of 2 64-bit-precision floating-point numbers. | | Method resolution order: | complex128 | complexfloating | inexact | number | generic | builtins.complex | builtins.object | | Methods defined here: | | __abs__(self, /) | abs(self) | | __add__(self, value, /) | Return self+value. | | __bool__(self, /) | self != 0 | | __eq__(self, value, /) | Return self==value. | | __float__(self, /) | float(self) | | __floordiv__(self, value, /) | Return self//value. | | __ge__(self, value, /) | Return self>=value. | | __gt__(self, value, /) | Return self>value. | | __hash__(self, /) | Return hash(self). | | __int__(self, /) | int(self) | | __le__(self, value, /) | Return self<=value. | | __lt__(self, value, /) | Return self<value. | | __mul__(self, value, /) | Return self*value. | | __ne__(self, value, /) | Return self!=value. | | __neg__(self, /) | -self | | __pos__(self, /) | +self | | __pow__(self, value, mod=None, /) | Return pow(self, value, mod). | | __radd__(self, value, /) | Return value+self. | | __repr__(self, /) | Return repr(self). | | __rfloordiv__(self, value, /) | Return value//self. | | __rmul__(self, value, /) | Return value*self. | | __rpow__(self, value, mod=None, /) | Return pow(value, self, mod). | | __rsub__(self, value, /) | Return value-self. | | __rtruediv__(self, value, /) | Return value/self. | | __str__(self, /) | Return str(self). | | __sub__(self, value, /) | Return self-value. | | __truediv__(self, value, /) | Return self/value. | | ---------------------------------------------------------------------- | Static methods defined here: | | __new__(*args, **kwargs) from builtins.type | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Methods inherited from complexfloating: | | __round__(...) | | ---------------------------------------------------------------------- | Methods inherited from generic: | | __and__(self, value, /) | Return self&value. | | __array__(...) | sc.__array__(dtype) return 0-dim array from scalar with specified dtype | | __array_wrap__(...) | sc.__array_wrap__(obj) return scalar from array | | __copy__(...) | | __deepcopy__(...) | | __divmod__(self, value, /) | Return divmod(self, value). | | __format__(...) | NumPy array scalar formatter | | __getitem__(self, key, /) | Return self[key]. | | __invert__(self, /) | ~self | | __lshift__(self, value, /) | Return self<<value. | | __mod__(self, value, /) | Return self%value. | | __or__(self, value, /) | Return self|value. | | __rand__(self, value, /) | Return value&self. | | __rdivmod__(self, value, /) | Return divmod(value, self). | | __reduce__(...) | Helper for pickle. | | __rlshift__(self, value, /) | Return value<<self. | | __rmod__(self, value, /) | Return value%self. | | __ror__(self, value, /) | Return value|self. | | __rrshift__(self, value, /) | Return value>>self. | | __rshift__(self, value, /) | Return self>>value. | | __rxor__(self, value, /) | Return value^self. | | __setstate__(...) | | __sizeof__(...) | Size of object in memory, in bytes. | | __xor__(self, value, /) | Return self^value. | | all(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | getfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | base | base object | | data | pointer to start of data | | dtype | get array data-descriptor | | flags | integer value of flags | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension | | ---------------------------------------------------------------------- | Methods inherited from builtins.complex: | | __getattribute__(self, name, /) | Return getattr(self, name). | | __getnewargs__(...) class complex256(complexfloating) | Complex number type composed of two extended-precision floating-point | numbers. | Character code: ``'G'``. | Canonical name: ``np.clongdouble``. | Alias: ``np.clongfloat``. | Alias: ``np.longcomplex``. | Alias *on this platform*: ``np.complex256``: Complex number type composed of 2 128-bit extended-precision floating-point numbers. | | Method resolution order: | complex256 | complexfloating | inexact | number | generic | builtins.object | | Methods defined here: | | __abs__(self, /) | abs(self) | | __add__(self, value, /) | Return self+value. | | __bool__(self, /) | self != 0 | | __complex__(...) | | __eq__(self, value, /) | Return self==value. | | __float__(self, /) | float(self) | | __floordiv__(self, value, /) | Return self//value. | | __ge__(self, value, /) | Return self>=value. | | __gt__(self, value, /) | Return self>value. | | __hash__(self, /) | Return hash(self). | | __int__(self, /) | int(self) | | __le__(self, value, /) | Return self<=value. | | __lt__(self, value, /) | Return self<value. | | __mul__(self, value, /) | Return self*value. | | __ne__(self, value, /) | Return self!=value. | | __neg__(self, /) | -self | | __pos__(self, /) | +self | | __pow__(self, value, mod=None, /) | Return pow(self, value, mod). | | __radd__(self, value, /) | Return value+self. | | __repr__(self, /) | Return repr(self). | | __rfloordiv__(self, value, /) | Return value//self. | | __rmul__(self, value, /) | Return value*self. | | __rpow__(self, value, mod=None, /) | Return pow(value, self, mod). | | __rsub__(self, value, /) | Return value-self. | | __rtruediv__(self, value, /) | Return value/self. | | __str__(self, /) | Return str(self). | | __sub__(self, value, /) | Return self-value. | | __truediv__(self, value, /) | Return self/value. | | ---------------------------------------------------------------------- | Static methods defined here: | | __new__(*args, **kwargs) from builtins.type | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Methods inherited from complexfloating: | | __round__(...) | | ---------------------------------------------------------------------- | Methods inherited from generic: | | __and__(self, value, /) | Return self&value. | | __array__(...) | sc.__array__(dtype) return 0-dim array from scalar with specified dtype | | __array_wrap__(...) | sc.__array_wrap__(obj) return scalar from array | | __copy__(...) | | __deepcopy__(...) | | __divmod__(self, value, /) | Return divmod(self, value). | | __format__(...) | NumPy array scalar formatter | | __getitem__(self, key, /) | Return self[key]. | | __invert__(self, /) | ~self | | __lshift__(self, value, /) | Return self<<value. | | __mod__(self, value, /) | Return self%value. | | __or__(self, value, /) | Return self|value. | | __rand__(self, value, /) | Return value&self. | | __rdivmod__(self, value, /) | Return divmod(value, self). | | __reduce__(...) | Helper for pickle. | | __rlshift__(self, value, /) | Return value<<self. | | __rmod__(self, value, /) | Return value%self. | | __ror__(self, value, /) | Return value|self. | | __rrshift__(self, value, /) | Return value>>self. | | __rshift__(self, value, /) | Return self>>value. | | __rxor__(self, value, /) | Return value^self. | | __setstate__(...) | | __sizeof__(...) | Size of object in memory, in bytes. | | __xor__(self, value, /) | Return self^value. | | all(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | getfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | base | base object | | data | pointer to start of data | | dtype | get array data-descriptor | | flags | integer value of flags | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension class complex64(complexfloating) | Complex number type composed of two single-precision floating-point | numbers. | Character code: ``'F'``. | Canonical name: ``np.csingle``. | Alias: ``np.singlecomplex``. | Alias *on this platform*: ``np.complex64``: Complex number type composed of 2 32-bit-precision floating-point numbers. | | Method resolution order: | complex64 | complexfloating | inexact | number | generic | builtins.object | | Methods defined here: | | __abs__(self, /) | abs(self) | | __add__(self, value, /) | Return self+value. | | __bool__(self, /) | self != 0 | | __complex__(...) | | __eq__(self, value, /) | Return self==value. | | __float__(self, /) | float(self) | | __floordiv__(self, value, /) | Return self//value. | | __ge__(self, value, /) | Return self>=value. | | __gt__(self, value, /) | Return self>value. | | __hash__(self, /) | Return hash(self). | | __int__(self, /) | int(self) | | __le__(self, value, /) | Return self<=value. | | __lt__(self, value, /) | Return self<value. | | __mul__(self, value, /) | Return self*value. | | __ne__(self, value, /) | Return self!=value. | | __neg__(self, /) | -self | | __pos__(self, /) | +self | | __pow__(self, value, mod=None, /) | Return pow(self, value, mod). | | __radd__(self, value, /) | Return value+self. | | __repr__(self, /) | Return repr(self). | | __rfloordiv__(self, value, /) | Return value//self. | | __rmul__(self, value, /) | Return value*self. | | __rpow__(self, value, mod=None, /) | Return pow(value, self, mod). | | __rsub__(self, value, /) | Return value-self. | | __rtruediv__(self, value, /) | Return value/self. | | __str__(self, /) | Return str(self). | | __sub__(self, value, /) | Return self-value. | | __truediv__(self, value, /) | Return self/value. | | ---------------------------------------------------------------------- | Static methods defined here: | | __new__(*args, **kwargs) from builtins.type | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Methods inherited from complexfloating: | | __round__(...) | | ---------------------------------------------------------------------- | Methods inherited from generic: | | __and__(self, value, /) | Return self&value. | | __array__(...) | sc.__array__(dtype) return 0-dim array from scalar with specified dtype | | __array_wrap__(...) | sc.__array_wrap__(obj) return scalar from array | | __copy__(...) | | __deepcopy__(...) | | __divmod__(self, value, /) | Return divmod(self, value). | | __format__(...) | NumPy array scalar formatter | | __getitem__(self, key, /) | Return self[key]. | | __invert__(self, /) | ~self | | __lshift__(self, value, /) | Return self<<value. | | __mod__(self, value, /) | Return self%value. | | __or__(self, value, /) | Return self|value. | | __rand__(self, value, /) | Return value&self. | | __rdivmod__(self, value, /) | Return divmod(value, self). | | __reduce__(...) | Helper for pickle. | | __rlshift__(self, value, /) | Return value<<self. | | __rmod__(self, value, /) | Return value%self. | | __ror__(self, value, /) | Return value|self. | | __rrshift__(self, value, /) | Return value>>self. | | __rshift__(self, value, /) | Return self>>value. | | __rxor__(self, value, /) | Return value^self. | | __setstate__(...) | | __sizeof__(...) | Size of object in memory, in bytes. | | __xor__(self, value, /) | Return self^value. | | all(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | getfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | base | base object | | data | pointer to start of data | | dtype | get array data-descriptor | | flags | integer value of flags | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension complex_ = class complex128(complexfloating, builtins.complex) | complex_(real=0, imag=0) | | Complex number type composed of two double-precision floating-point | numbers, compatible with Python `complex`. | Character code: ``'D'``. | Canonical name: ``np.cdouble``. | Alias: ``np.cfloat``. | Alias: ``np.complex_``. | Alias *on this platform*: ``np.complex128``: Complex number type composed of 2 64-bit-precision floating-point numbers. | | Method resolution order: | complex128 | complexfloating | inexact | number | generic | builtins.complex | builtins.object | | Methods defined here: | | __abs__(self, /) | abs(self) | | __add__(self, value, /) | Return self+value. | | __bool__(self, /) | self != 0 | | __eq__(self, value, /) | Return self==value. | | __float__(self, /) | float(self) | | __floordiv__(self, value, /) | Return self//value. | | __ge__(self, value, /) | Return self>=value. | | __gt__(self, value, /) | Return self>value. | | __hash__(self, /) | Return hash(self). | | __int__(self, /) | int(self) | | __le__(self, value, /) | Return self<=value. | | __lt__(self, value, /) | Return self<value. | | __mul__(self, value, /) | Return self*value. | | __ne__(self, value, /) | Return self!=value. | | __neg__(self, /) | -self | | __pos__(self, /) | +self | | __pow__(self, value, mod=None, /) | Return pow(self, value, mod). | | __radd__(self, value, /) | Return value+self. | | __repr__(self, /) | Return repr(self). | | __rfloordiv__(self, value, /) | Return value//self. | | __rmul__(self, value, /) | Return value*self. | | __rpow__(self, value, mod=None, /) | Return pow(value, self, mod). | | __rsub__(self, value, /) | Return value-self. | | __rtruediv__(self, value, /) | Return value/self. | | __str__(self, /) | Return str(self). | | __sub__(self, value, /) | Return self-value. | | __truediv__(self, value, /) | Return self/value. | | ---------------------------------------------------------------------- | Static methods defined here: | | __new__(*args, **kwargs) from builtins.type | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Methods inherited from complexfloating: | | __round__(...) | | ---------------------------------------------------------------------- | Methods inherited from generic: | | __and__(self, value, /) | Return self&value. | | __array__(...) | sc.__array__(dtype) return 0-dim array from scalar with specified dtype | | __array_wrap__(...) | sc.__array_wrap__(obj) return scalar from array | | __copy__(...) | | __deepcopy__(...) | | __divmod__(self, value, /) | Return divmod(self, value). | | __format__(...) | NumPy array scalar formatter | | __getitem__(self, key, /) | Return self[key]. | | __invert__(self, /) | ~self | | __lshift__(self, value, /) | Return self<<value. | | __mod__(self, value, /) | Return self%value. | | __or__(self, value, /) | Return self|value. | | __rand__(self, value, /) | Return value&self. | | __rdivmod__(self, value, /) | Return divmod(value, self). | | __reduce__(...) | Helper for pickle. | | __rlshift__(self, value, /) | Return value<<self. | | __rmod__(self, value, /) | Return value%self. | | __ror__(self, value, /) | Return value|self. | | __rrshift__(self, value, /) | Return value>>self. | | __rshift__(self, value, /) | Return self>>value. | | __rxor__(self, value, /) | Return value^self. | | __setstate__(...) | | __sizeof__(...) | Size of object in memory, in bytes. | | __xor__(self, value, /) | Return self^value. | | all(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | getfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | base | base object | | data | pointer to start of data | | dtype | get array data-descriptor | | flags | integer value of flags | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension | | ---------------------------------------------------------------------- | Methods inherited from builtins.complex: | | __getattribute__(self, name, /) | Return getattr(self, name). | | __getnewargs__(...) class complexfloating(inexact) | Abstract base class of all complex number scalar types that are made up of | floating-point numbers. | | Method resolution order: | complexfloating | inexact | number | generic | builtins.object | | Methods defined here: | | __round__(...) | | ---------------------------------------------------------------------- | Methods inherited from generic: | | __abs__(self, /) | abs(self) | | __add__(self, value, /) | Return self+value. | | __and__(self, value, /) | Return self&value. | | __array__(...) | sc.__array__(dtype) return 0-dim array from scalar with specified dtype | | __array_wrap__(...) | sc.__array_wrap__(obj) return scalar from array | | __bool__(self, /) | self != 0 | | __copy__(...) | | __deepcopy__(...) | | __divmod__(self, value, /) | Return divmod(self, value). | | __eq__(self, value, /) | Return self==value. | | __float__(self, /) | float(self) | | __floordiv__(self, value, /) | Return self//value. | | __format__(...) | NumPy array scalar formatter | | __ge__(self, value, /) | Return self>=value. | | __getitem__(self, key, /) | Return self[key]. | | __gt__(self, value, /) | Return self>value. | | __int__(self, /) | int(self) | | __invert__(self, /) | ~self | | __le__(self, value, /) | Return self<=value. | | __lshift__(self, value, /) | Return self<<value. | | __lt__(self, value, /) | Return self<value. | | __mod__(self, value, /) | Return self%value. | | __mul__(self, value, /) | Return self*value. | | __ne__(self, value, /) | Return self!=value. | | __neg__(self, /) | -self | | __or__(self, value, /) | Return self|value. | | __pos__(self, /) | +self | | __pow__(self, value, mod=None, /) | Return pow(self, value, mod). | | __radd__(self, value, /) | Return value+self. | | __rand__(self, value, /) | Return value&self. | | __rdivmod__(self, value, /) | Return divmod(value, self). | | __reduce__(...) | Helper for pickle. | | __rfloordiv__(self, value, /) | Return value//self. | | __rlshift__(self, value, /) | Return value<<self. | | __rmod__(self, value, /) | Return value%self. | | __rmul__(self, value, /) | Return value*self. | | __ror__(self, value, /) | Return value|self. | | __rpow__(self, value, mod=None, /) | Return pow(value, self, mod). | | __rrshift__(self, value, /) | Return value>>self. | | __rshift__(self, value, /) | Return self>>value. | | __rsub__(self, value, /) | Return value-self. | | __rtruediv__(self, value, /) | Return value/self. | | __rxor__(self, value, /) | Return value^self. | | __setstate__(...) | | __sizeof__(...) | Size of object in memory, in bytes. | | __sub__(self, value, /) | Return self-value. | | __truediv__(self, value, /) | Return self/value. | | __xor__(self, value, /) | Return self^value. | | all(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | getfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | base | base object | | data | pointer to start of data | | dtype | get array data-descriptor | | flags | integer value of flags | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension | | ---------------------------------------------------------------------- | Data and other attributes inherited from generic: | | __hash__ = None csingle = class complex64(complexfloating) | Complex number type composed of two single-precision floating-point | numbers. | Character code: ``'F'``. | Canonical name: ``np.csingle``. | Alias: ``np.singlecomplex``. | Alias *on this platform*: ``np.complex64``: Complex number type composed of 2 32-bit-precision floating-point numbers. | | Method resolution order: | complex64 | complexfloating | inexact | number | generic | builtins.object | | Methods defined here: | | __abs__(self, /) | abs(self) | | __add__(self, value, /) | Return self+value. | | __bool__(self, /) | self != 0 | | __complex__(...) | | __eq__(self, value, /) | Return self==value. | | __float__(self, /) | float(self) | | __floordiv__(self, value, /) | Return self//value. | | __ge__(self, value, /) | Return self>=value. | | __gt__(self, value, /) | Return self>value. | | __hash__(self, /) | Return hash(self). | | __int__(self, /) | int(self) | | __le__(self, value, /) | Return self<=value. | | __lt__(self, value, /) | Return self<value. | | __mul__(self, value, /) | Return self*value. | | __ne__(self, value, /) | Return self!=value. | | __neg__(self, /) | -self | | __pos__(self, /) | +self | | __pow__(self, value, mod=None, /) | Return pow(self, value, mod). | | __radd__(self, value, /) | Return value+self. | | __repr__(self, /) | Return repr(self). | | __rfloordiv__(self, value, /) | Return value//self. | | __rmul__(self, value, /) | Return value*self. | | __rpow__(self, value, mod=None, /) | Return pow(value, self, mod). | | __rsub__(self, value, /) | Return value-self. | | __rtruediv__(self, value, /) | Return value/self. | | __str__(self, /) | Return str(self). | | __sub__(self, value, /) | Return self-value. | | __truediv__(self, value, /) | Return self/value. | | ---------------------------------------------------------------------- | Static methods defined here: | | __new__(*args, **kwargs) from builtins.type | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Methods inherited from complexfloating: | | __round__(...) | | ---------------------------------------------------------------------- | Methods inherited from generic: | | __and__(self, value, /) | Return self&value. | | __array__(...) | sc.__array__(dtype) return 0-dim array from scalar with specified dtype | | __array_wrap__(...) | sc.__array_wrap__(obj) return scalar from array | | __copy__(...) | | __deepcopy__(...) | | __divmod__(self, value, /) | Return divmod(self, value). | | __format__(...) | NumPy array scalar formatter | | __getitem__(self, key, /) | Return self[key]. | | __invert__(self, /) | ~self | | __lshift__(self, value, /) | Return self<<value. | | __mod__(self, value, /) | Return self%value. | | __or__(self, value, /) | Return self|value. | | __rand__(self, value, /) | Return value&self. | | __rdivmod__(self, value, /) | Return divmod(value, self). | | __reduce__(...) | Helper for pickle. | | __rlshift__(self, value, /) | Return value<<self. | | __rmod__(self, value, /) | Return value%self. | | __ror__(self, value, /) | Return value|self. | | __rrshift__(self, value, /) | Return value>>self. | | __rshift__(self, value, /) | Return self>>value. | | __rxor__(self, value, /) | Return value^self. | | __setstate__(...) | | __sizeof__(...) | Size of object in memory, in bytes. | | __xor__(self, value, /) | Return self^value. | | all(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | getfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | base | base object | | data | pointer to start of data | | dtype | get array data-descriptor | | flags | integer value of flags | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension class datetime64(generic) | Base class for numpy scalar types. | | Class from which most (all?) numpy scalar types are derived. For | consistency, exposes the same API as `ndarray`, despite many | consequent attributes being either "get-only," or completely irrelevant. | This is the class from which it is strongly suggested users should derive | custom scalar types. | | Method resolution order: | datetime64 | generic | builtins.object | | Methods defined here: | | __eq__(self, value, /) | Return self==value. | | __ge__(self, value, /) | Return self>=value. | | __gt__(self, value, /) | Return self>value. | | __hash__(self, /) | Return hash(self). | | __le__(self, value, /) | Return self<=value. | | __lt__(self, value, /) | Return self<value. | | __ne__(self, value, /) | Return self!=value. | | __repr__(self, /) | Return repr(self). | | __str__(self, /) | Return str(self). | | ---------------------------------------------------------------------- | Static methods defined here: | | __new__(*args, **kwargs) from builtins.type | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Methods inherited from generic: | | __abs__(self, /) | abs(self) | | __add__(self, value, /) | Return self+value. | | __and__(self, value, /) | Return self&value. | | __array__(...) | sc.__array__(dtype) return 0-dim array from scalar with specified dtype | | __array_wrap__(...) | sc.__array_wrap__(obj) return scalar from array | | __bool__(self, /) | self != 0 | | __copy__(...) | | __deepcopy__(...) | | __divmod__(self, value, /) | Return divmod(self, value). | | __float__(self, /) | float(self) | | __floordiv__(self, value, /) | Return self//value. | | __format__(...) | NumPy array scalar formatter | | __getitem__(self, key, /) | Return self[key]. | | __int__(self, /) | int(self) | | __invert__(self, /) | ~self | | __lshift__(self, value, /) | Return self<<value. | | __mod__(self, value, /) | Return self%value. | | __mul__(self, value, /) | Return self*value. | | __neg__(self, /) | -self | | __or__(self, value, /) | Return self|value. | | __pos__(self, /) | +self | | __pow__(self, value, mod=None, /) | Return pow(self, value, mod). | | __radd__(self, value, /) | Return value+self. | | __rand__(self, value, /) | Return value&self. | | __rdivmod__(self, value, /) | Return divmod(value, self). | | __reduce__(...) | Helper for pickle. | | __rfloordiv__(self, value, /) | Return value//self. | | __rlshift__(self, value, /) | Return value<<self. | | __rmod__(self, value, /) | Return value%self. | | __rmul__(self, value, /) | Return value*self. | | __ror__(self, value, /) | Return value|self. | | __rpow__(self, value, mod=None, /) | Return pow(value, self, mod). | | __rrshift__(self, value, /) | Return value>>self. | | __rshift__(self, value, /) | Return self>>value. | | __rsub__(self, value, /) | Return value-self. | | __rtruediv__(self, value, /) | Return value/self. | | __rxor__(self, value, /) | Return value^self. | | __setstate__(...) | | __sizeof__(...) | Size of object in memory, in bytes. | | __sub__(self, value, /) | Return self-value. | | __truediv__(self, value, /) | Return self/value. | | __xor__(self, value, /) | Return self^value. | | all(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | getfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | base | base object | | data | pointer to start of data | | dtype | get array data-descriptor | | flags | integer value of flags | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension double = class float64(floating, builtins.float) | double(x=0, /) | | Double-precision floating-point number type, compatible with Python `float` | and C ``double``. | Character code: ``'d'``. | Canonical name: ``np.double``. | Alias: ``np.float_``. | Alias *on this platform*: ``np.float64``: 64-bit precision floating-point number type: sign bit, 11 bits exponent, 52 bits mantissa. | | Method resolution order: | float64 | floating | inexact | number | generic | builtins.float | builtins.object | | Methods defined here: | | __abs__(self, /) | abs(self) | | __add__(self, value, /) | Return self+value. | | __bool__(self, /) | self != 0 | | __divmod__(self, value, /) | Return divmod(self, value). | | __eq__(self, value, /) | Return self==value. | | __float__(self, /) | float(self) | | __floordiv__(self, value, /) | Return self//value. | | __ge__(self, value, /) | Return self>=value. | | __gt__(self, value, /) | Return self>value. | | __hash__(self, /) | Return hash(self). | | __int__(self, /) | int(self) | | __le__(self, value, /) | Return self<=value. | | __lt__(self, value, /) | Return self<value. | | __mod__(self, value, /) | Return self%value. | | __mul__(self, value, /) | Return self*value. | | __ne__(self, value, /) | Return self!=value. | | __neg__(self, /) | -self | | __pos__(self, /) | +self | | __pow__(self, value, mod=None, /) | Return pow(self, value, mod). | | __radd__(self, value, /) | Return value+self. | | __rdivmod__(self, value, /) | Return divmod(value, self). | | __repr__(self, /) | Return repr(self). | | __rfloordiv__(self, value, /) | Return value//self. | | __rmod__(self, value, /) | Return value%self. | | __rmul__(self, value, /) | Return value*self. | | __rpow__(self, value, mod=None, /) | Return pow(value, self, mod). | | __rsub__(self, value, /) | Return value-self. | | __rtruediv__(self, value, /) | Return value/self. | | __str__(self, /) | Return str(self). | | __sub__(self, value, /) | Return self-value. | | __truediv__(self, value, /) | Return self/value. | | as_integer_ratio(...) | double.as_integer_ratio() -> (int, int) | | Return a pair of integers, whose ratio is exactly equal to the original | floating point number, and with a positive denominator. | Raise OverflowError on infinities and a ValueError on NaNs. | | >>> np.double(10.0).as_integer_ratio() | (10, 1) | >>> np.double(0.0).as_integer_ratio() | (0, 1) | >>> np.double(-.25).as_integer_ratio() | (-1, 4) | | ---------------------------------------------------------------------- | Static methods defined here: | | __new__(*args, **kwargs) from builtins.type | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Methods inherited from floating: | | __round__(...) | | ---------------------------------------------------------------------- | Methods inherited from generic: | | __and__(self, value, /) | Return self&value. | | __array__(...) | sc.__array__(dtype) return 0-dim array from scalar with specified dtype | | __array_wrap__(...) | sc.__array_wrap__(obj) return scalar from array | | __copy__(...) | | __deepcopy__(...) | | __format__(...) | NumPy array scalar formatter | | __getitem__(self, key, /) | Return self[key]. | | __invert__(self, /) | ~self | | __lshift__(self, value, /) | Return self<<value. | | __or__(self, value, /) | Return self|value. | | __rand__(self, value, /) | Return value&self. | | __reduce__(...) | Helper for pickle. | | __rlshift__(self, value, /) | Return value<<self. | | __ror__(self, value, /) | Return value|self. | | __rrshift__(self, value, /) | Return value>>self. | | __rshift__(self, value, /) | Return self>>value. | | __rxor__(self, value, /) | Return value^self. | | __setstate__(...) | | __sizeof__(...) | Size of object in memory, in bytes. | | __xor__(self, value, /) | Return self^value. | | all(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | getfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | base | base object | | data | pointer to start of data | | dtype | get array data-descriptor | | flags | integer value of flags | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension | | ---------------------------------------------------------------------- | Methods inherited from builtins.float: | | __getattribute__(self, name, /) | Return getattr(self, name). | | __getnewargs__(self, /) | | __trunc__(self, /) | Return the Integral closest to x between 0 and x. | | hex(self, /) | Return a hexadecimal representation of a floating-point number. | | >>> (-0.1).hex() | '-0x1.999999999999ap-4' | >>> 3.14159.hex() | '0x1.921f9f01b866ep+1' | | is_integer(self, /) | Return True if the float is an integer. | | ---------------------------------------------------------------------- | Class methods inherited from builtins.float: | | __getformat__(typestr, /) from builtins.type | You probably don't want to use this function. | | typestr | Must be 'double' or 'float'. | | It exists mainly to be used in Python's test suite. | | 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. | | __set_format__(typestr, fmt, /) from builtins.type | You probably don't want to use this function. | | 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. | | It exists mainly to be used in Python's test suite. | | Override the automatic determination of C-level floating point type. | This affects how floats are converted to and from binary strings. | | fromhex(string, /) from builtins.type | Create a floating-point number from a hexadecimal string. | | >>> float.fromhex('0x1.ffffp10') | 2047.984375 | >>> float.fromhex('-0x1p-1074') | -5e-324 class dtype(builtins.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') | | Structured type, one field name 'f1', containing int16: | | >>> np.dtype([('f1', np.int16)]) | dtype([('f1', '<i2')]) | | Structured type, one field named 'f1', in itself containing a structured | type with one field: | | >>> np.dtype([('f1', [('f1', np.int16)])]) | dtype([('f1', [('f1', '<i2')])]) | | Structured type, two fields: the first field contains an unsigned int, the | second an int32: | | >>> np.dtype([('f1', np.uint64), ('f2', np.int32)]) | dtype([('f1', '<u8'), ('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.int64,3)),('world',np.void,10)]) | dtype([('hello', '<i8', (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((numpy.int16, [('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: | | __bool__(self, /) | self != 0 | | __eq__(self, value, /) | Return self==value. | | __ge__(self, value, /) | Return self>=value. | | __getitem__(self, key, /) | Return self[key]. | | __gt__(self, value, /) | Return self>value. | | __hash__(self, /) | Return hash(self). | | __le__(self, value, /) | Return self<=value. | | __len__(self, /) | Return len(self). | | __lt__(self, value, /) | Return self<value. | | __mul__(self, value, /) | Return self*value. | | __ne__(self, value, /) | Return self!=value. | | __reduce__(...) | Helper for pickle. | | __repr__(self, /) | Return repr(self). | | __rmul__(self, value, /) | Return value*self. | | __setstate__(...) | | __str__(self, /) | Return str(self). | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new dtype with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | Parameters | ---------- | new_order : string, optional | Byte order to force; a value from the byte order specifications | below. The default value ('S') results in swapping the current | byte order. `new_order` codes can be any of: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | The code does a case-insensitive check on the first letter of | `new_order` for these alternatives. For example, any of '>' | or 'B' or 'b' or 'brian' are valid to specify big-endian. | | Returns | ------- | new_dtype : dtype | New dtype object with the given change to the byte order. | | Notes | ----- | Changes are also made in all fields and sub-arrays of the data type. | | Examples | -------- | >>> import sys | >>> sys_is_le = sys.byteorder == 'little' | >>> native_code = sys_is_le and '<' or '>' | >>> swapped_code = sys_is_le and '>' or '<' | >>> native_dt = np.dtype(native_code+'i2') | >>> swapped_dt = np.dtype(swapped_code+'i2') | >>> native_dt.newbyteorder('S') == swapped_dt | True | >>> native_dt.newbyteorder() == swapped_dt | True | >>> native_dt == swapped_dt.newbyteorder('S') | True | >>> native_dt == swapped_dt.newbyteorder('=') | True | >>> native_dt == swapped_dt.newbyteorder('N') | True | >>> native_dt == native_dt.newbyteorder('|') | True | >>> np.dtype('<i2') == native_dt.newbyteorder('<') | True | >>> np.dtype('<i2') == native_dt.newbyteorder('L') | True | >>> np.dtype('>i2') == native_dt.newbyteorder('>') | True | >>> np.dtype('>i2') == native_dt.newbyteorder('B') | True | | ---------------------------------------------------------------------- | Static methods defined here: | | __new__(*args, **kwargs) from builtins.type | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Data descriptors defined here: | | alignment | The required alignment (bytes) of this data-type according to the compiler. | | More information is available in the C-API section of the manual. | | Examples | -------- | | >>> x = np.dtype('i4') | >>> x.alignment | 4 | | >>> x = np.dtype(float) | >>> x.alignment | 8 | | base | Returns dtype for the base element of the subarrays, | regardless of their dimension or shape. | | See Also | -------- | dtype.subdtype | | Examples | -------- | >>> x = numpy.dtype('8f') | >>> x.base | dtype('float32') | | >>> x = numpy.dtype('i2') | >>> x.base | dtype('int16') | | byteorder | A character indicating the byte-order of this data-type object. | | One of: | | === ============== | '=' native | '<' little-endian | '>' big-endian | '|' not applicable | === ============== | | All built-in data-type objects have byteorder either '=' or '|'. | | Examples | -------- | | >>> dt = np.dtype('i2') | >>> dt.byteorder | '=' | >>> # endian is not relevant for 8 bit numbers | >>> np.dtype('i1').byteorder | '|' | >>> # or ASCII strings | >>> np.dtype('S2').byteorder | '|' | >>> # Even if specific code is given, and it is native | >>> # '=' is the byteorder | >>> import sys | >>> sys_is_le = sys.byteorder == 'little' | >>> native_code = sys_is_le and '<' or '>' | >>> swapped_code = sys_is_le and '>' or '<' | >>> dt = np.dtype(native_code + 'i2') | >>> dt.byteorder | '=' | >>> # Swapped code shows up as itself | >>> dt = np.dtype(swapped_code + 'i2') | >>> dt.byteorder == swapped_code | True | | char | A unique character code for each of the 21 different built-in types. | | Examples | -------- | | >>> x = np.dtype(float) | >>> x.char | 'd' | | descr | `__array_interface__` description of the data-type. | | The format is that required by the 'descr' key in the | `__array_interface__` attribute. | | Warning: This attribute exists specifically for `__array_interface__`, | and passing it directly to `np.dtype` will not accurately reconstruct | some dtypes (e.g., scalar and subarray dtypes). | | Examples | -------- | | >>> x = np.dtype(float) | >>> x.descr | [('', '<f8')] | | >>> dt = np.dtype([('name', np.str_, 16), ('grades', np.float64, (2,))]) | >>> dt.descr | [('name', '<U16'), ('grades', '<f8', (2,))] | | fields | Dictionary of named fields defined for this data type, or ``None``. | | The dictionary is indexed by keys that are the names of the fields. | Each entry in the dictionary is a tuple fully describing the field:: | | (dtype, offset[, title]) | | Offset is limited to C int, which is signed and usually 32 bits. | If present, the optional title can be any object (if it is a string | or unicode then it will also be a key in the fields dictionary, | otherwise it's meta-data). Notice also that the first two elements | of the tuple can be passed directly as arguments to the ``ndarray.getfield`` | and ``ndarray.setfield`` methods. | | See Also | -------- | ndarray.getfield, ndarray.setfield | | Examples | -------- | >>> dt = np.dtype([('name', np.str_, 16), ('grades', np.float64, (2,))]) | >>> print(dt.fields) | {'grades': (dtype(('float64',(2,))), 16), 'name': (dtype('|S16'), 0)} | | flags | Bit-flags describing how this data type is to be interpreted. | | Bit-masks are in `numpy.core.multiarray` as the constants | `ITEM_HASOBJECT`, `LIST_PICKLE`, `ITEM_IS_POINTER`, `NEEDS_INIT`, | `NEEDS_PYAPI`, `USE_GETITEM`, `USE_SETITEM`. A full explanation | of these flags is in C-API documentation; they are largely useful | for user-defined data-types. | | The following example demonstrates that operations on this particular | dtype requires Python C-API. | | Examples | -------- | | >>> x = np.dtype([('a', np.int32, 8), ('b', np.float64, 6)]) | >>> x.flags | 16 | >>> np.core.multiarray.NEEDS_PYAPI | 16 | | hasobject | Boolean indicating whether this dtype contains any reference-counted | objects in any fields or sub-dtypes. | | Recall that what is actually in the ndarray memory representing | the Python object is the memory address of that object (a pointer). | Special handling may be required, and this attribute is useful for | distinguishing data types that may contain arbitrary Python objects | and data-types that won't. | | isalignedstruct | Boolean indicating whether the dtype is a struct which maintains | field alignment. This flag is sticky, so when combining multiple | structs together, it is preserved and produces new dtypes which | are also aligned. | | isbuiltin | Integer indicating how this dtype relates to the built-in dtypes. | | Read-only. | | = ======================================================================== | 0 if this is a structured array type, with fields | 1 if this is a dtype compiled into numpy (such as ints, floats etc) | 2 if the dtype is for a user-defined numpy type | A user-defined type uses the numpy C-API machinery to extend | numpy to handle a new array type. See | :ref:`user.user-defined-data-types` in the NumPy manual. | = ======================================================================== | | Examples | -------- | >>> dt = np.dtype('i2') | >>> dt.isbuiltin | 1 | >>> dt = np.dtype('f8') | >>> dt.isbuiltin | 1 | >>> dt = np.dtype([('field1', 'f8')]) | >>> dt.isbuiltin | 0 | | isnative | Boolean indicating whether the byte order of this dtype is native | to the platform. | | itemsize | The element size of this data-type object. | | For 18 of the 21 types this number is fixed by the data-type. | For the flexible data-types, this number can be anything. | | Examples | -------- | | >>> arr = np.array([[1, 2], [3, 4]]) | >>> arr.dtype | dtype('int64') | >>> arr.itemsize | 8 | | >>> dt = np.dtype([('name', np.str_, 16), ('grades', np.float64, (2,))]) | >>> dt.itemsize | 80 | | kind | A character code (one of 'biufcmMOSUV') identifying the general kind of data. | | = ====================== | b boolean | i signed integer | u unsigned integer | f floating-point | c complex floating-point | m timedelta | M datetime | O object | S (byte-)string | U Unicode | V void | = ====================== | | Examples | -------- | | >>> dt = np.dtype('i4') | >>> dt.kind | 'i' | >>> dt = np.dtype('f8') | >>> dt.kind | 'f' | >>> dt = np.dtype([('field1', 'f8')]) | >>> dt.kind | 'V' | | metadata | | name | A bit-width name for this data-type. | | Un-sized flexible data-type objects do not have this attribute. | | Examples | -------- | | >>> x = np.dtype(float) | >>> x.name | 'float64' | >>> x = np.dtype([('a', np.int32, 8), ('b', np.float64, 6)]) | >>> x.name | 'void640' | | names | Ordered list of field names, or ``None`` if there are no fields. | | The names are ordered according to increasing byte offset. This can be | used, for example, to walk through all of the named fields in offset order. | | Examples | -------- | >>> dt = np.dtype([('name', np.str_, 16), ('grades', np.float64, (2,))]) | >>> dt.names | ('name', 'grades') | | ndim | Number of dimensions of the sub-array if this data type describes a | sub-array, and ``0`` otherwise. | | .. versionadded:: 1.13.0 | | Examples | -------- | >>> x = np.dtype(float) | >>> x.ndim | 0 | | >>> x = np.dtype((float, 8)) | >>> x.ndim | 1 | | >>> x = np.dtype(('i4', (3, 4))) | >>> x.ndim | 2 | | num | A unique number for each of the 21 different built-in types. | | These are roughly ordered from least-to-most precision. | | Examples | -------- | | >>> dt = np.dtype(str) | >>> dt.num | 19 | | >>> dt = np.dtype(float) | >>> dt.num | 12 | | shape | Shape tuple of the sub-array if this data type describes a sub-array, | and ``()`` otherwise. | | Examples | -------- | | >>> dt = np.dtype(('i4', 4)) | >>> dt.shape | (4,) | | >>> dt = np.dtype(('i4', (2, 3))) | >>> dt.shape | (2, 3) | | str | The array-protocol typestring of this data-type object. | | subdtype | Tuple ``(item_dtype, shape)`` if this `dtype` describes a sub-array, and | None otherwise. | | The *shape* is the fixed shape of the sub-array described by this | data type, and *item_dtype* the data type of the array. | | If a field whose dtype object has this attribute is retrieved, | then the extra dimensions implied by *shape* are tacked on to | the end of the retrieved array. | | See Also | -------- | dtype.base | | Examples | -------- | >>> x = numpy.dtype('8f') | >>> x.subdtype | (dtype('float32'), (8,)) | | >>> x = numpy.dtype('i2') | >>> x.subdtype | >>> | | type | The type object used to instantiate a scalar of this data-type. class errstate(contextlib.ContextDecorator) | errstate(*, call=<numpy.core._ufunc_config._unspecified object at 0x7f9924126dc0>, **kwargs) | | errstate(**kwargs) | | Context manager for floating-point error handling. | | Using an instance of `errstate` as a context manager allows statements in | that context to execute with a known error handling behavior. Upon entering | the context the error handling is set with `seterr` and `seterrcall`, and | upon exiting it is reset to what it was before. | | .. versionchanged:: 1.17.0 | `errstate` is also usable as a function decorator, saving | a level of indentation if an entire function is wrapped. | See :py:class:`contextlib.ContextDecorator` for more information. | | Parameters | ---------- | kwargs : {divide, over, under, invalid} | Keyword arguments. The valid keywords are the possible floating-point | exceptions. Each keyword should have a string value that defines the | treatment for the particular error. Possible values are | {'ignore', 'warn', 'raise', 'call', 'print', 'log'}. | | See Also | -------- | seterr, geterr, seterrcall, geterrcall | | Notes | ----- | For complete documentation of the types of floating-point exceptions and | treatment options, see `seterr`. | | Examples | -------- | >>> from collections import OrderedDict | >>> olderr = np.seterr(all='ignore') # Set error handling to known state. | | >>> np.arange(3) / 0. | array([nan, inf, inf]) | >>> with np.errstate(divide='warn'): | ... np.arange(3) / 0. | array([nan, inf, inf]) | | >>> np.sqrt(-1) | nan | >>> with np.errstate(invalid='raise'): | ... np.sqrt(-1) | Traceback (most recent call last): | File "<stdin>", line 2, in <module> | FloatingPointError: invalid value encountered in sqrt | | Outside the context the error handling behavior has not changed: | | >>> OrderedDict(sorted(np.geterr().items())) | OrderedDict([('divide', 'ignore'), ('invalid', 'ignore'), ('over', 'ignore'), ('under', 'ignore')]) | | Method resolution order: | errstate | contextlib.ContextDecorator | builtins.object | | Methods defined here: | | __enter__(self) | | __exit__(self, *exc_info) | | __init__(self, *, call=<numpy.core._ufunc_config._unspecified object at 0x7f9924126dc0>, **kwargs) | Initialize self. See help(type(self)) for accurate signature. | | ---------------------------------------------------------------------- | Methods inherited from contextlib.ContextDecorator: | | __call__(self, func) | Call self as a function. | | ---------------------------------------------------------------------- | Data descriptors inherited from contextlib.ContextDecorator: | | __dict__ | dictionary for instance variables (if defined) | | __weakref__ | list of weak references to the object (if defined) class finfo(builtins.object) | finfo(dtype) | | finfo(dtype) | | Machine limits for floating point types. | | Attributes | ---------- | bits : int | The number of bits occupied by the type. | eps : float | The difference between 1.0 and the next smallest representable float | larger than 1.0. For example, for 64-bit binary floats in the IEEE-754 | standard, ``eps = 2**-52``, approximately 2.22e-16. | epsneg : float | The difference between 1.0 and the next smallest representable float | less than 1.0. For example, for 64-bit binary floats in the IEEE-754 | standard, ``epsneg = 2**-53``, approximately 1.11e-16. | iexp : int | The number of bits in the exponent portion of the floating point | representation. | machar : MachAr | The object which calculated these parameters and holds more | detailed information. | machep : int | The exponent that yields `eps`. | max : floating point number of the appropriate type | The largest representable number. | maxexp : int | The smallest positive power of the base (2) that causes overflow. | min : floating point number of the appropriate type | The smallest representable number, typically ``-max``. | minexp : int | The most negative power of the base (2) consistent with there | being no leading 0's in the mantissa. | negep : int | The exponent that yields `epsneg`. | nexp : int | The number of bits in the exponent including its sign and bias. | nmant : int | The number of bits in the mantissa. | precision : int | The approximate number of decimal digits to which this kind of | float is precise. | resolution : floating point number of the appropriate type | The approximate decimal resolution of this type, i.e., | ``10**-precision``. | tiny : float | The smallest positive usable number. Type of `tiny` is an | appropriate floating point type. | | Parameters | ---------- | dtype : float, dtype, or instance | Kind of floating point data-type about which to get information. | | See Also | -------- | MachAr : The implementation of the tests that produce this information. | iinfo : The equivalent for integer data types. | spacing : The distance between a value and the nearest adjacent number | nextafter : The next floating point value after x1 towards x2 | | Notes | ----- | For developers of NumPy: do not instantiate this at the module level. | The initial calculation of these parameters is expensive and negatively | impacts import times. These objects are cached, so calling ``finfo()`` | repeatedly inside your functions is not a problem. | | Methods defined here: | | __repr__(self) | Return repr(self). | | __str__(self) | Return str(self). | | ---------------------------------------------------------------------- | Static methods defined here: | | __new__(cls, dtype) | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Data descriptors defined here: | | __dict__ | dictionary for instance variables (if defined) | | __weakref__ | list of weak references to the object (if defined) class flatiter(builtins.object) | Flat iterator object to iterate over arrays. | | A `flatiter` iterator is returned by ``x.flat`` for any array `x`. | It allows iterating over the array as if it were a 1-D array, | either in a for-loop or by calling its `next` method. | | Iteration is done in row-major, C-style order (the last | index varying the fastest). The iterator can also be indexed using | basic slicing or advanced indexing. | | See Also | -------- | ndarray.flat : Return a flat iterator over an array. | ndarray.flatten : Returns a flattened copy of an array. | | Notes | ----- | A `flatiter` iterator can not be constructed directly from Python code | by calling the `flatiter` constructor. | | Examples | -------- | >>> x = np.arange(6).reshape(2, 3) | >>> fl = x.flat | >>> type(fl) | <class 'numpy.flatiter'> | >>> for item in fl: | ... print(item) | ... | 0 | 1 | 2 | 3 | 4 | 5 | | >>> fl[2:4] | array([2, 3]) | | Methods defined here: | | __array__(...) | __array__(type=None) Get array from iterator | | __delitem__(self, key, /) | Delete self[key]. | | __eq__(self, value, /) | Return self==value. | | __ge__(self, value, /) | Return self>=value. | | __getitem__(self, key, /) | Return self[key]. | | __gt__(self, value, /) | Return self>value. | | __iter__(self, /) | Implement iter(self). | | __le__(self, value, /) | Return self<=value. | | __len__(self, /) | Return len(self). | | __lt__(self, value, /) | Return self<value. | | __ne__(self, value, /) | Return self!=value. | | __next__(self, /) | Implement next(self). | | __setitem__(self, key, value, /) | Set self[key] to value. | | copy(...) | copy() | | Get a copy of the iterator as a 1-D array. | | Examples | -------- | >>> x = np.arange(6).reshape(2, 3) | >>> x | array([[0, 1, 2], | [3, 4, 5]]) | >>> fl = x.flat | >>> fl.copy() | array([0, 1, 2, 3, 4, 5]) | | ---------------------------------------------------------------------- | Data descriptors defined here: | | base | A reference to the array that is iterated over. | | Examples | -------- | >>> x = np.arange(5) | >>> fl = x.flat | >>> fl.base is x | True | | coords | An N-dimensional tuple of current coordinates. | | Examples | -------- | >>> x = np.arange(6).reshape(2, 3) | >>> fl = x.flat | >>> fl.coords | (0, 0) | >>> next(fl) | 0 | >>> fl.coords | (0, 1) | | index | Current flat index into the array. | | Examples | -------- | >>> x = np.arange(6).reshape(2, 3) | >>> fl = x.flat | >>> fl.index | 0 | >>> next(fl) | 0 | >>> fl.index | 1 | | ---------------------------------------------------------------------- | Data and other attributes defined here: | | __hash__ = None class flexible(generic) | Abstract base class of all scalar types without predefined length. | The actual size of these types depends on the specific `np.dtype` | instantiation. | | Method resolution order: | flexible | generic | builtins.object | | Methods inherited from generic: | | __abs__(self, /) | abs(self) | | __add__(self, value, /) | Return self+value. | | __and__(self, value, /) | Return self&value. | | __array__(...) | sc.__array__(dtype) return 0-dim array from scalar with specified dtype | | __array_wrap__(...) | sc.__array_wrap__(obj) return scalar from array | | __bool__(self, /) | self != 0 | | __copy__(...) | | __deepcopy__(...) | | __divmod__(self, value, /) | Return divmod(self, value). | | __eq__(self, value, /) | Return self==value. | | __float__(self, /) | float(self) | | __floordiv__(self, value, /) | Return self//value. | | __format__(...) | NumPy array scalar formatter | | __ge__(self, value, /) | Return self>=value. | | __getitem__(self, key, /) | Return self[key]. | | __gt__(self, value, /) | Return self>value. | | __int__(self, /) | int(self) | | __invert__(self, /) | ~self | | __le__(self, value, /) | Return self<=value. | | __lshift__(self, value, /) | Return self<<value. | | __lt__(self, value, /) | Return self<value. | | __mod__(self, value, /) | Return self%value. | | __mul__(self, value, /) | Return self*value. | | __ne__(self, value, /) | Return self!=value. | | __neg__(self, /) | -self | | __or__(self, value, /) | Return self|value. | | __pos__(self, /) | +self | | __pow__(self, value, mod=None, /) | Return pow(self, value, mod). | | __radd__(self, value, /) | Return value+self. | | __rand__(self, value, /) | Return value&self. | | __rdivmod__(self, value, /) | Return divmod(value, self). | | __reduce__(...) | Helper for pickle. | | __rfloordiv__(self, value, /) | Return value//self. | | __rlshift__(self, value, /) | Return value<<self. | | __rmod__(self, value, /) | Return value%self. | | __rmul__(self, value, /) | Return value*self. | | __ror__(self, value, /) | Return value|self. | | __rpow__(self, value, mod=None, /) | Return pow(value, self, mod). | | __rrshift__(self, value, /) | Return value>>self. | | __rshift__(self, value, /) | Return self>>value. | | __rsub__(self, value, /) | Return value-self. | | __rtruediv__(self, value, /) | Return value/self. | | __rxor__(self, value, /) | Return value^self. | | __setstate__(...) | | __sizeof__(...) | Size of object in memory, in bytes. | | __sub__(self, value, /) | Return self-value. | | __truediv__(self, value, /) | Return self/value. | | __xor__(self, value, /) | Return self^value. | | all(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | getfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | base | base object | | data | pointer to start of data | | dtype | get array data-descriptor | | flags | integer value of flags | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension | | ---------------------------------------------------------------------- | Data and other attributes inherited from generic: | | __hash__ = None class float128(floating) | Extended-precision floating-point number type, compatible with C | ``long double`` but not necessarily with IEEE 754 quadruple-precision. | Character code: ``'g'``. | Canonical name: ``np.longdouble``. | Alias: ``np.longfloat``. | Alias *on this platform*: ``np.float128``: 128-bit extended-precision floating-point number type. | | Method resolution order: | float128 | floating | inexact | number | generic | builtins.object | | Methods defined here: | | __abs__(self, /) | abs(self) | | __add__(self, value, /) | Return self+value. | | __bool__(self, /) | self != 0 | | __divmod__(self, value, /) | Return divmod(self, value). | | __eq__(self, value, /) | Return self==value. | | __float__(self, /) | float(self) | | __floordiv__(self, value, /) | Return self//value. | | __ge__(self, value, /) | Return self>=value. | | __gt__(self, value, /) | Return self>value. | | __hash__(self, /) | Return hash(self). | | __int__(self, /) | int(self) | | __le__(self, value, /) | Return self<=value. | | __lt__(self, value, /) | Return self<value. | | __mod__(self, value, /) | Return self%value. | | __mul__(self, value, /) | Return self*value. | | __ne__(self, value, /) | Return self!=value. | | __neg__(self, /) | -self | | __pos__(self, /) | +self | | __pow__(self, value, mod=None, /) | Return pow(self, value, mod). | | __radd__(self, value, /) | Return value+self. | | __rdivmod__(self, value, /) | Return divmod(value, self). | | __repr__(self, /) | Return repr(self). | | __rfloordiv__(self, value, /) | Return value//self. | | __rmod__(self, value, /) | Return value%self. | | __rmul__(self, value, /) | Return value*self. | | __rpow__(self, value, mod=None, /) | Return pow(value, self, mod). | | __rsub__(self, value, /) | Return value-self. | | __rtruediv__(self, value, /) | Return value/self. | | __str__(self, /) | Return str(self). | | __sub__(self, value, /) | Return self-value. | | __truediv__(self, value, /) | Return self/value. | | as_integer_ratio(...) | longdouble.as_integer_ratio() -> (int, int) | | Return a pair of integers, whose ratio is exactly equal to the original | floating point number, and with a positive denominator. | Raise OverflowError on infinities and a ValueError on NaNs. | | >>> np.longdouble(10.0).as_integer_ratio() | (10, 1) | >>> np.longdouble(0.0).as_integer_ratio() | (0, 1) | >>> np.longdouble(-.25).as_integer_ratio() | (-1, 4) | | ---------------------------------------------------------------------- | Static methods defined here: | | __new__(*args, **kwargs) from builtins.type | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Methods inherited from floating: | | __round__(...) | | ---------------------------------------------------------------------- | Methods inherited from generic: | | __and__(self, value, /) | Return self&value. | | __array__(...) | sc.__array__(dtype) return 0-dim array from scalar with specified dtype | | __array_wrap__(...) | sc.__array_wrap__(obj) return scalar from array | | __copy__(...) | | __deepcopy__(...) | | __format__(...) | NumPy array scalar formatter | | __getitem__(self, key, /) | Return self[key]. | | __invert__(self, /) | ~self | | __lshift__(self, value, /) | Return self<<value. | | __or__(self, value, /) | Return self|value. | | __rand__(self, value, /) | Return value&self. | | __reduce__(...) | Helper for pickle. | | __rlshift__(self, value, /) | Return value<<self. | | __ror__(self, value, /) | Return value|self. | | __rrshift__(self, value, /) | Return value>>self. | | __rshift__(self, value, /) | Return self>>value. | | __rxor__(self, value, /) | Return value^self. | | __setstate__(...) | | __sizeof__(...) | Size of object in memory, in bytes. | | __xor__(self, value, /) | Return self^value. | | all(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | getfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | base | base object | | data | pointer to start of data | | dtype | get array data-descriptor | | flags | integer value of flags | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension class float16(floating) | Half-precision floating-point number type. | Character code: ``'e'``. | Canonical name: ``np.half``. | Alias *on this platform*: ``np.float16``: 16-bit-precision floating-point number type: sign bit, 5 bits exponent, 10 bits mantissa. | | Method resolution order: | float16 | floating | inexact | number | generic | builtins.object | | Methods defined here: | | __abs__(self, /) | abs(self) | | __add__(self, value, /) | Return self+value. | | __bool__(self, /) | self != 0 | | __divmod__(self, value, /) | Return divmod(self, value). | | __eq__(self, value, /) | Return self==value. | | __float__(self, /) | float(self) | | __floordiv__(self, value, /) | Return self//value. | | __ge__(self, value, /) | Return self>=value. | | __gt__(self, value, /) | Return self>value. | | __hash__(self, /) | Return hash(self). | | __int__(self, /) | int(self) | | __le__(self, value, /) | Return self<=value. | | __lt__(self, value, /) | Return self<value. | | __mod__(self, value, /) | Return self%value. | | __mul__(self, value, /) | Return self*value. | | __ne__(self, value, /) | Return self!=value. | | __neg__(self, /) | -self | | __pos__(self, /) | +self | | __pow__(self, value, mod=None, /) | Return pow(self, value, mod). | | __radd__(self, value, /) | Return value+self. | | __rdivmod__(self, value, /) | Return divmod(value, self). | | __repr__(self, /) | Return repr(self). | | __rfloordiv__(self, value, /) | Return value//self. | | __rmod__(self, value, /) | Return value%self. | | __rmul__(self, value, /) | Return value*self. | | __rpow__(self, value, mod=None, /) | Return pow(value, self, mod). | | __rsub__(self, value, /) | Return value-self. | | __rtruediv__(self, value, /) | Return value/self. | | __str__(self, /) | Return str(self). | | __sub__(self, value, /) | Return self-value. | | __truediv__(self, value, /) | Return self/value. | | as_integer_ratio(...) | half.as_integer_ratio() -> (int, int) | | Return a pair of integers, whose ratio is exactly equal to the original | floating point number, and with a positive denominator. | Raise OverflowError on infinities and a ValueError on NaNs. | | >>> np.half(10.0).as_integer_ratio() | (10, 1) | >>> np.half(0.0).as_integer_ratio() | (0, 1) | >>> np.half(-.25).as_integer_ratio() | (-1, 4) | | ---------------------------------------------------------------------- | Static methods defined here: | | __new__(*args, **kwargs) from builtins.type | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Methods inherited from floating: | | __round__(...) | | ---------------------------------------------------------------------- | Methods inherited from generic: | | __and__(self, value, /) | Return self&value. | | __array__(...) | sc.__array__(dtype) return 0-dim array from scalar with specified dtype | | __array_wrap__(...) | sc.__array_wrap__(obj) return scalar from array | | __copy__(...) | | __deepcopy__(...) | | __format__(...) | NumPy array scalar formatter | | __getitem__(self, key, /) | Return self[key]. | | __invert__(self, /) | ~self | | __lshift__(self, value, /) | Return self<<value. | | __or__(self, value, /) | Return self|value. | | __rand__(self, value, /) | Return value&self. | | __reduce__(...) | Helper for pickle. | | __rlshift__(self, value, /) | Return value<<self. | | __ror__(self, value, /) | Return value|self. | | __rrshift__(self, value, /) | Return value>>self. | | __rshift__(self, value, /) | Return self>>value. | | __rxor__(self, value, /) | Return value^self. | | __setstate__(...) | | __sizeof__(...) | Size of object in memory, in bytes. | | __xor__(self, value, /) | Return self^value. | | all(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | getfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | base | base object | | data | pointer to start of data | | dtype | get array data-descriptor | | flags | integer value of flags | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension class float32(floating) | Single-precision floating-point number type, compatible with C ``float``. | Character code: ``'f'``. | Canonical name: ``np.single``. | Alias *on this platform*: ``np.float32``: 32-bit-precision floating-point number type: sign bit, 8 bits exponent, 23 bits mantissa. | | Method resolution order: | float32 | floating | inexact | number | generic | builtins.object | | Methods defined here: | | __abs__(self, /) | abs(self) | | __add__(self, value, /) | Return self+value. | | __bool__(self, /) | self != 0 | | __divmod__(self, value, /) | Return divmod(self, value). | | __eq__(self, value, /) | Return self==value. | | __float__(self, /) | float(self) | | __floordiv__(self, value, /) | Return self//value. | | __ge__(self, value, /) | Return self>=value. | | __gt__(self, value, /) | Return self>value. | | __hash__(self, /) | Return hash(self). | | __int__(self, /) | int(self) | | __le__(self, value, /) | Return self<=value. | | __lt__(self, value, /) | Return self<value. | | __mod__(self, value, /) | Return self%value. | | __mul__(self, value, /) | Return self*value. | | __ne__(self, value, /) | Return self!=value. | | __neg__(self, /) | -self | | __pos__(self, /) | +self | | __pow__(self, value, mod=None, /) | Return pow(self, value, mod). | | __radd__(self, value, /) | Return value+self. | | __rdivmod__(self, value, /) | Return divmod(value, self). | | __repr__(self, /) | Return repr(self). | | __rfloordiv__(self, value, /) | Return value//self. | | __rmod__(self, value, /) | Return value%self. | | __rmul__(self, value, /) | Return value*self. | | __rpow__(self, value, mod=None, /) | Return pow(value, self, mod). | | __rsub__(self, value, /) | Return value-self. | | __rtruediv__(self, value, /) | Return value/self. | | __str__(self, /) | Return str(self). | | __sub__(self, value, /) | Return self-value. | | __truediv__(self, value, /) | Return self/value. | | as_integer_ratio(...) | single.as_integer_ratio() -> (int, int) | | Return a pair of integers, whose ratio is exactly equal to the original | floating point number, and with a positive denominator. | Raise OverflowError on infinities and a ValueError on NaNs. | | >>> np.single(10.0).as_integer_ratio() | (10, 1) | >>> np.single(0.0).as_integer_ratio() | (0, 1) | >>> np.single(-.25).as_integer_ratio() | (-1, 4) | | ---------------------------------------------------------------------- | Static methods defined here: | | __new__(*args, **kwargs) from builtins.type | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Methods inherited from floating: | | __round__(...) | | ---------------------------------------------------------------------- | Methods inherited from generic: | | __and__(self, value, /) | Return self&value. | | __array__(...) | sc.__array__(dtype) return 0-dim array from scalar with specified dtype | | __array_wrap__(...) | sc.__array_wrap__(obj) return scalar from array | | __copy__(...) | | __deepcopy__(...) | | __format__(...) | NumPy array scalar formatter | | __getitem__(self, key, /) | Return self[key]. | | __invert__(self, /) | ~self | | __lshift__(self, value, /) | Return self<<value. | | __or__(self, value, /) | Return self|value. | | __rand__(self, value, /) | Return value&self. | | __reduce__(...) | Helper for pickle. | | __rlshift__(self, value, /) | Return value<<self. | | __ror__(self, value, /) | Return value|self. | | __rrshift__(self, value, /) | Return value>>self. | | __rshift__(self, value, /) | Return self>>value. | | __rxor__(self, value, /) | Return value^self. | | __setstate__(...) | | __sizeof__(...) | Size of object in memory, in bytes. | | __xor__(self, value, /) | Return self^value. | | all(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | getfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | base | base object | | data | pointer to start of data | | dtype | get array data-descriptor | | flags | integer value of flags | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension class float64(floating, builtins.float) | float64(x=0, /) | | Double-precision floating-point number type, compatible with Python `float` | and C ``double``. | Character code: ``'d'``. | Canonical name: ``np.double``. | Alias: ``np.float_``. | Alias *on this platform*: ``np.float64``: 64-bit precision floating-point number type: sign bit, 11 bits exponent, 52 bits mantissa. | | Method resolution order: | float64 | floating | inexact | number | generic | builtins.float | builtins.object | | Methods defined here: | | __abs__(self, /) | abs(self) | | __add__(self, value, /) | Return self+value. | | __bool__(self, /) | self != 0 | | __divmod__(self, value, /) | Return divmod(self, value). | | __eq__(self, value, /) | Return self==value. | | __float__(self, /) | float(self) | | __floordiv__(self, value, /) | Return self//value. | | __ge__(self, value, /) | Return self>=value. | | __gt__(self, value, /) | Return self>value. | | __hash__(self, /) | Return hash(self). | | __int__(self, /) | int(self) | | __le__(self, value, /) | Return self<=value. | | __lt__(self, value, /) | Return self<value. | | __mod__(self, value, /) | Return self%value. | | __mul__(self, value, /) | Return self*value. | | __ne__(self, value, /) | Return self!=value. | | __neg__(self, /) | -self | | __pos__(self, /) | +self | | __pow__(self, value, mod=None, /) | Return pow(self, value, mod). | | __radd__(self, value, /) | Return value+self. | | __rdivmod__(self, value, /) | Return divmod(value, self). | | __repr__(self, /) | Return repr(self). | | __rfloordiv__(self, value, /) | Return value//self. | | __rmod__(self, value, /) | Return value%self. | | __rmul__(self, value, /) | Return value*self. | | __rpow__(self, value, mod=None, /) | Return pow(value, self, mod). | | __rsub__(self, value, /) | Return value-self. | | __rtruediv__(self, value, /) | Return value/self. | | __str__(self, /) | Return str(self). | | __sub__(self, value, /) | Return self-value. | | __truediv__(self, value, /) | Return self/value. | | as_integer_ratio(...) | double.as_integer_ratio() -> (int, int) | | Return a pair of integers, whose ratio is exactly equal to the original | floating point number, and with a positive denominator. | Raise OverflowError on infinities and a ValueError on NaNs. | | >>> np.double(10.0).as_integer_ratio() | (10, 1) | >>> np.double(0.0).as_integer_ratio() | (0, 1) | >>> np.double(-.25).as_integer_ratio() | (-1, 4) | | ---------------------------------------------------------------------- | Static methods defined here: | | __new__(*args, **kwargs) from builtins.type | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Methods inherited from floating: | | __round__(...) | | ---------------------------------------------------------------------- | Methods inherited from generic: | | __and__(self, value, /) | Return self&value. | | __array__(...) | sc.__array__(dtype) return 0-dim array from scalar with specified dtype | | __array_wrap__(...) | sc.__array_wrap__(obj) return scalar from array | | __copy__(...) | | __deepcopy__(...) | | __format__(...) | NumPy array scalar formatter | | __getitem__(self, key, /) | Return self[key]. | | __invert__(self, /) | ~self | | __lshift__(self, value, /) | Return self<<value. | | __or__(self, value, /) | Return self|value. | | __rand__(self, value, /) | Return value&self. | | __reduce__(...) | Helper for pickle. | | __rlshift__(self, value, /) | Return value<<self. | | __ror__(self, value, /) | Return value|self. | | __rrshift__(self, value, /) | Return value>>self. | | __rshift__(self, value, /) | Return self>>value. | | __rxor__(self, value, /) | Return value^self. | | __setstate__(...) | | __sizeof__(...) | Size of object in memory, in bytes. | | __xor__(self, value, /) | Return self^value. | | all(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | getfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | base | base object | | data | pointer to start of data | | dtype | get array data-descriptor | | flags | integer value of flags | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension | | ---------------------------------------------------------------------- | Methods inherited from builtins.float: | | __getattribute__(self, name, /) | Return getattr(self, name). | | __getnewargs__(self, /) | | __trunc__(self, /) | Return the Integral closest to x between 0 and x. | | hex(self, /) | Return a hexadecimal representation of a floating-point number. | | >>> (-0.1).hex() | '-0x1.999999999999ap-4' | >>> 3.14159.hex() | '0x1.921f9f01b866ep+1' | | is_integer(self, /) | Return True if the float is an integer. | | ---------------------------------------------------------------------- | Class methods inherited from builtins.float: | | __getformat__(typestr, /) from builtins.type | You probably don't want to use this function. | | typestr | Must be 'double' or 'float'. | | It exists mainly to be used in Python's test suite. | | 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. | | __set_format__(typestr, fmt, /) from builtins.type | You probably don't want to use this function. | | 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. | | It exists mainly to be used in Python's test suite. | | Override the automatic determination of C-level floating point type. | This affects how floats are converted to and from binary strings. | | fromhex(string, /) from builtins.type | Create a floating-point number from a hexadecimal string. | | >>> float.fromhex('0x1.ffffp10') | 2047.984375 | >>> float.fromhex('-0x1p-1074') | -5e-324 float_ = class float64(floating, builtins.float) | float_(x=0, /) | | Double-precision floating-point number type, compatible with Python `float` | and C ``double``. | Character code: ``'d'``. | Canonical name: ``np.double``. | Alias: ``np.float_``. | Alias *on this platform*: ``np.float64``: 64-bit precision floating-point number type: sign bit, 11 bits exponent, 52 bits mantissa. | | Method resolution order: | float64 | floating | inexact | number | generic | builtins.float | builtins.object | | Methods defined here: | | __abs__(self, /) | abs(self) | | __add__(self, value, /) | Return self+value. | | __bool__(self, /) | self != 0 | | __divmod__(self, value, /) | Return divmod(self, value). | | __eq__(self, value, /) | Return self==value. | | __float__(self, /) | float(self) | | __floordiv__(self, value, /) | Return self//value. | | __ge__(self, value, /) | Return self>=value. | | __gt__(self, value, /) | Return self>value. | | __hash__(self, /) | Return hash(self). | | __int__(self, /) | int(self) | | __le__(self, value, /) | Return self<=value. | | __lt__(self, value, /) | Return self<value. | | __mod__(self, value, /) | Return self%value. | | __mul__(self, value, /) | Return self*value. | | __ne__(self, value, /) | Return self!=value. | | __neg__(self, /) | -self | | __pos__(self, /) | +self | | __pow__(self, value, mod=None, /) | Return pow(self, value, mod). | | __radd__(self, value, /) | Return value+self. | | __rdivmod__(self, value, /) | Return divmod(value, self). | | __repr__(self, /) | Return repr(self). | | __rfloordiv__(self, value, /) | Return value//self. | | __rmod__(self, value, /) | Return value%self. | | __rmul__(self, value, /) | Return value*self. | | __rpow__(self, value, mod=None, /) | Return pow(value, self, mod). | | __rsub__(self, value, /) | Return value-self. | | __rtruediv__(self, value, /) | Return value/self. | | __str__(self, /) | Return str(self). | | __sub__(self, value, /) | Return self-value. | | __truediv__(self, value, /) | Return self/value. | | as_integer_ratio(...) | double.as_integer_ratio() -> (int, int) | | Return a pair of integers, whose ratio is exactly equal to the original | floating point number, and with a positive denominator. | Raise OverflowError on infinities and a ValueError on NaNs. | | >>> np.double(10.0).as_integer_ratio() | (10, 1) | >>> np.double(0.0).as_integer_ratio() | (0, 1) | >>> np.double(-.25).as_integer_ratio() | (-1, 4) | | ---------------------------------------------------------------------- | Static methods defined here: | | __new__(*args, **kwargs) from builtins.type | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Methods inherited from floating: | | __round__(...) | | ---------------------------------------------------------------------- | Methods inherited from generic: | | __and__(self, value, /) | Return self&value. | | __array__(...) | sc.__array__(dtype) return 0-dim array from scalar with specified dtype | | __array_wrap__(...) | sc.__array_wrap__(obj) return scalar from array | | __copy__(...) | | __deepcopy__(...) | | __format__(...) | NumPy array scalar formatter | | __getitem__(self, key, /) | Return self[key]. | | __invert__(self, /) | ~self | | __lshift__(self, value, /) | Return self<<value. | | __or__(self, value, /) | Return self|value. | | __rand__(self, value, /) | Return value&self. | | __reduce__(...) | Helper for pickle. | | __rlshift__(self, value, /) | Return value<<self. | | __ror__(self, value, /) | Return value|self. | | __rrshift__(self, value, /) | Return value>>self. | | __rshift__(self, value, /) | Return self>>value. | | __rxor__(self, value, /) | Return value^self. | | __setstate__(...) | | __sizeof__(...) | Size of object in memory, in bytes. | | __xor__(self, value, /) | Return self^value. | | all(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | getfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | base | base object | | data | pointer to start of data | | dtype | get array data-descriptor | | flags | integer value of flags | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension | | ---------------------------------------------------------------------- | Methods inherited from builtins.float: | | __getattribute__(self, name, /) | Return getattr(self, name). | | __getnewargs__(self, /) | | __trunc__(self, /) | Return the Integral closest to x between 0 and x. | | hex(self, /) | Return a hexadecimal representation of a floating-point number. | | >>> (-0.1).hex() | '-0x1.999999999999ap-4' | >>> 3.14159.hex() | '0x1.921f9f01b866ep+1' | | is_integer(self, /) | Return True if the float is an integer. | | ---------------------------------------------------------------------- | Class methods inherited from builtins.float: | | __getformat__(typestr, /) from builtins.type | You probably don't want to use this function. | | typestr | Must be 'double' or 'float'. | | It exists mainly to be used in Python's test suite. | | 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. | | __set_format__(typestr, fmt, /) from builtins.type | You probably don't want to use this function. | | 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. | | It exists mainly to be used in Python's test suite. | | Override the automatic determination of C-level floating point type. | This affects how floats are converted to and from binary strings. | | fromhex(string, /) from builtins.type | Create a floating-point number from a hexadecimal string. | | >>> float.fromhex('0x1.ffffp10') | 2047.984375 | >>> float.fromhex('-0x1p-1074') | -5e-324 class floating(inexact) | Abstract base class of all floating-point scalar types. | | Method resolution order: | floating | inexact | number | generic | builtins.object | | Methods defined here: | | __round__(...) | | ---------------------------------------------------------------------- | Methods inherited from generic: | | __abs__(self, /) | abs(self) | | __add__(self, value, /) | Return self+value. | | __and__(self, value, /) | Return self&value. | | __array__(...) | sc.__array__(dtype) return 0-dim array from scalar with specified dtype | | __array_wrap__(...) | sc.__array_wrap__(obj) return scalar from array | | __bool__(self, /) | self != 0 | | __copy__(...) | | __deepcopy__(...) | | __divmod__(self, value, /) | Return divmod(self, value). | | __eq__(self, value, /) | Return self==value. | | __float__(self, /) | float(self) | | __floordiv__(self, value, /) | Return self//value. | | __format__(...) | NumPy array scalar formatter | | __ge__(self, value, /) | Return self>=value. | | __getitem__(self, key, /) | Return self[key]. | | __gt__(self, value, /) | Return self>value. | | __int__(self, /) | int(self) | | __invert__(self, /) | ~self | | __le__(self, value, /) | Return self<=value. | | __lshift__(self, value, /) | Return self<<value. | | __lt__(self, value, /) | Return self<value. | | __mod__(self, value, /) | Return self%value. | | __mul__(self, value, /) | Return self*value. | | __ne__(self, value, /) | Return self!=value. | | __neg__(self, /) | -self | | __or__(self, value, /) | Return self|value. | | __pos__(self, /) | +self | | __pow__(self, value, mod=None, /) | Return pow(self, value, mod). | | __radd__(self, value, /) | Return value+self. | | __rand__(self, value, /) | Return value&self. | | __rdivmod__(self, value, /) | Return divmod(value, self). | | __reduce__(...) | Helper for pickle. | | __rfloordiv__(self, value, /) | Return value//self. | | __rlshift__(self, value, /) | Return value<<self. | | __rmod__(self, value, /) | Return value%self. | | __rmul__(self, value, /) | Return value*self. | | __ror__(self, value, /) | Return value|self. | | __rpow__(self, value, mod=None, /) | Return pow(value, self, mod). | | __rrshift__(self, value, /) | Return value>>self. | | __rshift__(self, value, /) | Return self>>value. | | __rsub__(self, value, /) | Return value-self. | | __rtruediv__(self, value, /) | Return value/self. | | __rxor__(self, value, /) | Return value^self. | | __setstate__(...) | | __sizeof__(...) | Size of object in memory, in bytes. | | __sub__(self, value, /) | Return self-value. | | __truediv__(self, value, /) | Return self/value. | | __xor__(self, value, /) | Return self^value. | | all(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | getfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | base | base object | | data | pointer to start of data | | dtype | get array data-descriptor | | flags | integer value of flags | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension | | ---------------------------------------------------------------------- | Data and other attributes inherited from generic: | | __hash__ = None class format_parser(builtins.object) | format_parser(formats, names, titles, aligned=False, byteorder=None) | | Class to convert formats, names, titles description to a dtype. | | After constructing the format_parser object, the dtype attribute is | the converted data-type: | ``dtype = format_parser(formats, names, titles).dtype`` | | Attributes | ---------- | dtype : dtype | The converted data-type. | | Parameters | ---------- | formats : str or list of str | The format description, either specified as a string with | comma-separated format descriptions in the form ``'f8, i4, a5'``, or | a list of format description strings in the form | ``['f8', 'i4', 'a5']``. | names : str or list/tuple of str | The field names, either specified as a comma-separated string in the | form ``'col1, col2, col3'``, or as a list or tuple of strings in the | form ``['col1', 'col2', 'col3']``. | An empty list can be used, in that case default field names | ('f0', 'f1', ...) are used. | titles : sequence | Sequence of title strings. An empty list can be used to leave titles | out. | aligned : bool, optional | If True, align the fields by padding as the C-compiler would. | Default is False. | byteorder : str, optional | If specified, all the fields will be changed to the | provided byte-order. Otherwise, the default byte-order is | used. For all available string specifiers, see `dtype.newbyteorder`. | | See Also | -------- | dtype, typename, sctype2char | | Examples | -------- | >>> np.format_parser(['<f8', '<i4', '<a5'], ['col1', 'col2', 'col3'], | ... ['T1', 'T2', 'T3']).dtype | dtype([(('T1', 'col1'), '<f8'), (('T2', 'col2'), '<i4'), (('T3', 'col3'), 'S5')]) | | `names` and/or `titles` can be empty lists. If `titles` is an empty list, | titles will simply not appear. If `names` is empty, default field names | will be used. | | >>> np.format_parser(['f8', 'i4', 'a5'], ['col1', 'col2', 'col3'], | ... []).dtype | dtype([('col1', '<f8'), ('col2', '<i4'), ('col3', '<S5')]) | >>> np.format_parser(['<f8', '<i4', '<a5'], [], []).dtype | dtype([('f0', '<f8'), ('f1', '<i4'), ('f2', 'S5')]) | | Methods defined here: | | __init__(self, formats, names, titles, aligned=False, byteorder=None) | Initialize self. See help(type(self)) for accurate signature. | | ---------------------------------------------------------------------- | Data descriptors defined here: | | __dict__ | dictionary for instance variables (if defined) | | __weakref__ | list of weak references to the object (if defined) class generic(builtins.object) | Base class for numpy scalar types. | | Class from which most (all?) numpy scalar types are derived. For | consistency, exposes the same API as `ndarray`, despite many | consequent attributes being either "get-only," or completely irrelevant. | This is the class from which it is strongly suggested users should derive | custom scalar types. | | Methods defined here: | | __abs__(self, /) | abs(self) | | __add__(self, value, /) | Return self+value. | | __and__(self, value, /) | Return self&value. | | __array__(...) | sc.__array__(dtype) return 0-dim array from scalar with specified dtype | | __array_wrap__(...) | sc.__array_wrap__(obj) return scalar from array | | __bool__(self, /) | self != 0 | | __copy__(...) | | __deepcopy__(...) | | __divmod__(self, value, /) | Return divmod(self, value). | | __eq__(self, value, /) | Return self==value. | | __float__(self, /) | float(self) | | __floordiv__(self, value, /) | Return self//value. | | __format__(...) | NumPy array scalar formatter | | __ge__(self, value, /) | Return self>=value. | | __getitem__(self, key, /) | Return self[key]. | | __gt__(self, value, /) | Return self>value. | | __int__(self, /) | int(self) | | __invert__(self, /) | ~self | | __le__(self, value, /) | Return self<=value. | | __lshift__(self, value, /) | Return self<<value. | | __lt__(self, value, /) | Return self<value. | | __mod__(self, value, /) | Return self%value. | | __mul__(self, value, /) | Return self*value. | | __ne__(self, value, /) | Return self!=value. | | __neg__(self, /) | -self | | __or__(self, value, /) | Return self|value. | | __pos__(self, /) | +self | | __pow__(self, value, mod=None, /) | Return pow(self, value, mod). | | __radd__(self, value, /) | Return value+self. | | __rand__(self, value, /) | Return value&self. | | __rdivmod__(self, value, /) | Return divmod(value, self). | | __reduce__(...) | Helper for pickle. | | __rfloordiv__(self, value, /) | Return value//self. | | __rlshift__(self, value, /) | Return value<<self. | | __rmod__(self, value, /) | Return value%self. | | __rmul__(self, value, /) | Return value*self. | | __ror__(self, value, /) | Return value|self. | | __rpow__(self, value, mod=None, /) | Return pow(value, self, mod). | | __rrshift__(self, value, /) | Return value>>self. | | __rshift__(self, value, /) | Return self>>value. | | __rsub__(self, value, /) | Return value-self. | | __rtruediv__(self, value, /) | Return value/self. | | __rxor__(self, value, /) | Return value^self. | | __setstate__(...) | | __sizeof__(...) | Size of object in memory, in bytes. | | __sub__(self, value, /) | Return self-value. | | __truediv__(self, value, /) | Return self/value. | | __xor__(self, value, /) | Return self^value. | | all(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | getfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors defined here: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | base | base object | | data | pointer to start of data | | dtype | get array data-descriptor | | flags | integer value of flags | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension | | ---------------------------------------------------------------------- | Data and other attributes defined here: | | __hash__ = None half = class float16(floating) | Half-precision floating-point number type. | Character code: ``'e'``. | Canonical name: ``np.half``. | Alias *on this platform*: ``np.float16``: 16-bit-precision floating-point number type: sign bit, 5 bits exponent, 10 bits mantissa. | | Method resolution order: | float16 | floating | inexact | number | generic | builtins.object | | Methods defined here: | | __abs__(self, /) | abs(self) | | __add__(self, value, /) | Return self+value. | | __bool__(self, /) | self != 0 | | __divmod__(self, value, /) | Return divmod(self, value). | | __eq__(self, value, /) | Return self==value. | | __float__(self, /) | float(self) | | __floordiv__(self, value, /) | Return self//value. | | __ge__(self, value, /) | Return self>=value. | | __gt__(self, value, /) | Return self>value. | | __hash__(self, /) | Return hash(self). | | __int__(self, /) | int(self) | | __le__(self, value, /) | Return self<=value. | | __lt__(self, value, /) | Return self<value. | | __mod__(self, value, /) | Return self%value. | | __mul__(self, value, /) | Return self*value. | | __ne__(self, value, /) | Return self!=value. | | __neg__(self, /) | -self | | __pos__(self, /) | +self | | __pow__(self, value, mod=None, /) | Return pow(self, value, mod). | | __radd__(self, value, /) | Return value+self. | | __rdivmod__(self, value, /) | Return divmod(value, self). | | __repr__(self, /) | Return repr(self). | | __rfloordiv__(self, value, /) | Return value//self. | | __rmod__(self, value, /) | Return value%self. | | __rmul__(self, value, /) | Return value*self. | | __rpow__(self, value, mod=None, /) | Return pow(value, self, mod). | | __rsub__(self, value, /) | Return value-self. | | __rtruediv__(self, value, /) | Return value/self. | | __str__(self, /) | Return str(self). | | __sub__(self, value, /) | Return self-value. | | __truediv__(self, value, /) | Return self/value. | | as_integer_ratio(...) | half.as_integer_ratio() -> (int, int) | | Return a pair of integers, whose ratio is exactly equal to the original | floating point number, and with a positive denominator. | Raise OverflowError on infinities and a ValueError on NaNs. | | >>> np.half(10.0).as_integer_ratio() | (10, 1) | >>> np.half(0.0).as_integer_ratio() | (0, 1) | >>> np.half(-.25).as_integer_ratio() | (-1, 4) | | ---------------------------------------------------------------------- | Static methods defined here: | | __new__(*args, **kwargs) from builtins.type | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Methods inherited from floating: | | __round__(...) | | ---------------------------------------------------------------------- | Methods inherited from generic: | | __and__(self, value, /) | Return self&value. | | __array__(...) | sc.__array__(dtype) return 0-dim array from scalar with specified dtype | | __array_wrap__(...) | sc.__array_wrap__(obj) return scalar from array | | __copy__(...) | | __deepcopy__(...) | | __format__(...) | NumPy array scalar formatter | | __getitem__(self, key, /) | Return self[key]. | | __invert__(self, /) | ~self | | __lshift__(self, value, /) | Return self<<value. | | __or__(self, value, /) | Return self|value. | | __rand__(self, value, /) | Return value&self. | | __reduce__(...) | Helper for pickle. | | __rlshift__(self, value, /) | Return value<<self. | | __ror__(self, value, /) | Return value|self. | | __rrshift__(self, value, /) | Return value>>self. | | __rshift__(self, value, /) | Return self>>value. | | __rxor__(self, value, /) | Return value^self. | | __setstate__(...) | | __sizeof__(...) | Size of object in memory, in bytes. | | __xor__(self, value, /) | Return self^value. | | all(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | getfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | base | base object | | data | pointer to start of data | | dtype | get array data-descriptor | | flags | integer value of flags | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension class iinfo(builtins.object) | iinfo(int_type) | | iinfo(type) | | Machine limits for integer types. | | Attributes | ---------- | bits : int | The number of bits occupied by the type. | min : int | The smallest integer expressible by the type. | max : int | The largest integer expressible by the type. | | Parameters | ---------- | int_type : integer type, dtype, or instance | The kind of integer data type to get information about. | | See Also | -------- | finfo : The equivalent for floating point data types. | | Examples | -------- | With types: | | >>> ii16 = np.iinfo(np.int16) | >>> ii16.min | -32768 | >>> ii16.max | 32767 | >>> ii32 = np.iinfo(np.int32) | >>> ii32.min | -2147483648 | >>> ii32.max | 2147483647 | | With instances: | | >>> ii32 = np.iinfo(np.int32(10)) | >>> ii32.min | -2147483648 | >>> ii32.max | 2147483647 | | Methods defined here: | | __init__(self, int_type) | Initialize self. See help(type(self)) for accurate signature. | | __repr__(self) | Return repr(self). | | __str__(self) | String representation. | | ---------------------------------------------------------------------- | Readonly properties defined here: | | max | Maximum value of given dtype. | | min | Minimum value of given dtype. | | ---------------------------------------------------------------------- | Data descriptors defined here: | | __dict__ | dictionary for instance variables (if defined) | | __weakref__ | list of weak references to the object (if defined) class inexact(number) | Abstract base class of all numeric scalar types with a (potentially) | inexact representation of the values in its range, such as | floating-point numbers. | | Method resolution order: | inexact | number | generic | builtins.object | | Methods inherited from generic: | | __abs__(self, /) | abs(self) | | __add__(self, value, /) | Return self+value. | | __and__(self, value, /) | Return self&value. | | __array__(...) | sc.__array__(dtype) return 0-dim array from scalar with specified dtype | | __array_wrap__(...) | sc.__array_wrap__(obj) return scalar from array | | __bool__(self, /) | self != 0 | | __copy__(...) | | __deepcopy__(...) | | __divmod__(self, value, /) | Return divmod(self, value). | | __eq__(self, value, /) | Return self==value. | | __float__(self, /) | float(self) | | __floordiv__(self, value, /) | Return self//value. | | __format__(...) | NumPy array scalar formatter | | __ge__(self, value, /) | Return self>=value. | | __getitem__(self, key, /) | Return self[key]. | | __gt__(self, value, /) | Return self>value. | | __int__(self, /) | int(self) | | __invert__(self, /) | ~self | | __le__(self, value, /) | Return self<=value. | | __lshift__(self, value, /) | Return self<<value. | | __lt__(self, value, /) | Return self<value. | | __mod__(self, value, /) | Return self%value. | | __mul__(self, value, /) | Return self*value. | | __ne__(self, value, /) | Return self!=value. | | __neg__(self, /) | -self | | __or__(self, value, /) | Return self|value. | | __pos__(self, /) | +self | | __pow__(self, value, mod=None, /) | Return pow(self, value, mod). | | __radd__(self, value, /) | Return value+self. | | __rand__(self, value, /) | Return value&self. | | __rdivmod__(self, value, /) | Return divmod(value, self). | | __reduce__(...) | Helper for pickle. | | __rfloordiv__(self, value, /) | Return value//self. | | __rlshift__(self, value, /) | Return value<<self. | | __rmod__(self, value, /) | Return value%self. | | __rmul__(self, value, /) | Return value*self. | | __ror__(self, value, /) | Return value|self. | | __rpow__(self, value, mod=None, /) | Return pow(value, self, mod). | | __rrshift__(self, value, /) | Return value>>self. | | __rshift__(self, value, /) | Return self>>value. | | __rsub__(self, value, /) | Return value-self. | | __rtruediv__(self, value, /) | Return value/self. | | __rxor__(self, value, /) | Return value^self. | | __setstate__(...) | | __sizeof__(...) | Size of object in memory, in bytes. | | __sub__(self, value, /) | Return self-value. | | __truediv__(self, value, /) | Return self/value. | | __xor__(self, value, /) | Return self^value. | | all(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | getfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | base | base object | | data | pointer to start of data | | dtype | get array data-descriptor | | flags | integer value of flags | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension | | ---------------------------------------------------------------------- | Data and other attributes inherited from generic: | | __hash__ = None int0 = class int64(signedinteger) | Signed integer type, compatible with Python `int` anc C ``long``. | Character code: ``'l'``. | Canonical name: ``np.int_``. | Alias *on this platform*: ``np.int64``: 64-bit signed integer (-9223372036854775808 to 9223372036854775807). | Alias *on this platform*: ``np.intp``: Signed integer large enough to fit pointer, compatible with C ``intptr_t``. | | Method resolution order: | int64 | signedinteger | integer | number | generic | builtins.object | | Methods defined here: | | __abs__(self, /) | abs(self) | | __add__(self, value, /) | Return self+value. | | __and__(self, value, /) | Return self&value. | | __bool__(self, /) | self != 0 | | __divmod__(self, value, /) | Return divmod(self, value). | | __eq__(self, value, /) | Return self==value. | | __float__(self, /) | float(self) | | __floordiv__(self, value, /) | Return self//value. | | __ge__(self, value, /) | Return self>=value. | | __gt__(self, value, /) | Return self>value. | | __hash__(self, /) | Return hash(self). | | __index__(self, /) | Return self converted to an integer, if self is suitable for use as an index into a list. | | __int__(self, /) | int(self) | | __invert__(self, /) | ~self | | __le__(self, value, /) | Return self<=value. | | __lshift__(self, value, /) | Return self<<value. | | __lt__(self, value, /) | Return self<value. | | __mod__(self, value, /) | Return self%value. | | __mul__(self, value, /) | Return self*value. | | __ne__(self, value, /) | Return self!=value. | | __neg__(self, /) | -self | | __or__(self, value, /) | Return self|value. | | __pos__(self, /) | +self | | __pow__(self, value, mod=None, /) | Return pow(self, value, mod). | | __radd__(self, value, /) | Return value+self. | | __rand__(self, value, /) | Return value&self. | | __rdivmod__(self, value, /) | Return divmod(value, self). | | __repr__(self, /) | Return repr(self). | | __rfloordiv__(self, value, /) | Return value//self. | | __rlshift__(self, value, /) | Return value<<self. | | __rmod__(self, value, /) | Return value%self. | | __rmul__(self, value, /) | Return value*self. | | __ror__(self, value, /) | Return value|self. | | __rpow__(self, value, mod=None, /) | Return pow(value, self, mod). | | __rrshift__(self, value, /) | Return value>>self. | | __rshift__(self, value, /) | Return self>>value. | | __rsub__(self, value, /) | Return value-self. | | __rtruediv__(self, value, /) | Return value/self. | | __rxor__(self, value, /) | Return value^self. | | __str__(self, /) | Return str(self). | | __sub__(self, value, /) | Return self-value. | | __truediv__(self, value, /) | Return self/value. | | __xor__(self, value, /) | Return self^value. | | ---------------------------------------------------------------------- | Static methods defined here: | | __new__(*args, **kwargs) from builtins.type | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Methods inherited from integer: | | __round__(...) | | ---------------------------------------------------------------------- | Data descriptors inherited from integer: | | denominator | denominator of value (1) | | numerator | numerator of value (the value itself) | | ---------------------------------------------------------------------- | Methods inherited from generic: | | __array__(...) | sc.__array__(dtype) return 0-dim array from scalar with specified dtype | | __array_wrap__(...) | sc.__array_wrap__(obj) return scalar from array | | __copy__(...) | | __deepcopy__(...) | | __format__(...) | NumPy array scalar formatter | | __getitem__(self, key, /) | Return self[key]. | | __reduce__(...) | Helper for pickle. | | __setstate__(...) | | __sizeof__(...) | Size of object in memory, in bytes. | | all(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | getfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | base | base object | | data | pointer to start of data | | dtype | get array data-descriptor | | flags | integer value of flags | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension class int16(signedinteger) | Signed integer type, compatible with C ``short``. | Character code: ``'h'``. | Canonical name: ``np.short``. | Alias *on this platform*: ``np.int16``: 16-bit signed integer (-32768 to 32767). | | Method resolution order: | int16 | signedinteger | integer | number | generic | builtins.object | | Methods defined here: | | __abs__(self, /) | abs(self) | | __add__(self, value, /) | Return self+value. | | __and__(self, value, /) | Return self&value. | | __bool__(self, /) | self != 0 | | __divmod__(self, value, /) | Return divmod(self, value). | | __eq__(self, value, /) | Return self==value. | | __float__(self, /) | float(self) | | __floordiv__(self, value, /) | Return self//value. | | __ge__(self, value, /) | Return self>=value. | | __gt__(self, value, /) | Return self>value. | | __hash__(self, /) | Return hash(self). | | __index__(self, /) | Return self converted to an integer, if self is suitable for use as an index into a list. | | __int__(self, /) | int(self) | | __invert__(self, /) | ~self | | __le__(self, value, /) | Return self<=value. | | __lshift__(self, value, /) | Return self<<value. | | __lt__(self, value, /) | Return self<value. | | __mod__(self, value, /) | Return self%value. | | __mul__(self, value, /) | Return self*value. | | __ne__(self, value, /) | Return self!=value. | | __neg__(self, /) | -self | | __or__(self, value, /) | Return self|value. | | __pos__(self, /) | +self | | __pow__(self, value, mod=None, /) | Return pow(self, value, mod). | | __radd__(self, value, /) | Return value+self. | | __rand__(self, value, /) | Return value&self. | | __rdivmod__(self, value, /) | Return divmod(value, self). | | __repr__(self, /) | Return repr(self). | | __rfloordiv__(self, value, /) | Return value//self. | | __rlshift__(self, value, /) | Return value<<self. | | __rmod__(self, value, /) | Return value%self. | | __rmul__(self, value, /) | Return value*self. | | __ror__(self, value, /) | Return value|self. | | __rpow__(self, value, mod=None, /) | Return pow(value, self, mod). | | __rrshift__(self, value, /) | Return value>>self. | | __rshift__(self, value, /) | Return self>>value. | | __rsub__(self, value, /) | Return value-self. | | __rtruediv__(self, value, /) | Return value/self. | | __rxor__(self, value, /) | Return value^self. | | __str__(self, /) | Return str(self). | | __sub__(self, value, /) | Return self-value. | | __truediv__(self, value, /) | Return self/value. | | __xor__(self, value, /) | Return self^value. | | ---------------------------------------------------------------------- | Static methods defined here: | | __new__(*args, **kwargs) from builtins.type | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Methods inherited from integer: | | __round__(...) | | ---------------------------------------------------------------------- | Data descriptors inherited from integer: | | denominator | denominator of value (1) | | numerator | numerator of value (the value itself) | | ---------------------------------------------------------------------- | Methods inherited from generic: | | __array__(...) | sc.__array__(dtype) return 0-dim array from scalar with specified dtype | | __array_wrap__(...) | sc.__array_wrap__(obj) return scalar from array | | __copy__(...) | | __deepcopy__(...) | | __format__(...) | NumPy array scalar formatter | | __getitem__(self, key, /) | Return self[key]. | | __reduce__(...) | Helper for pickle. | | __setstate__(...) | | __sizeof__(...) | Size of object in memory, in bytes. | | all(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | getfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | base | base object | | data | pointer to start of data | | dtype | get array data-descriptor | | flags | integer value of flags | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension class int32(signedinteger) | Signed integer type, compatible with C ``int``. | Character code: ``'i'``. | Canonical name: ``np.intc``. | Alias *on this platform*: ``np.int32``: 32-bit signed integer (-2147483648 to 2147483647). | | Method resolution order: | int32 | signedinteger | integer | number | generic | builtins.object | | Methods defined here: | | __abs__(self, /) | abs(self) | | __add__(self, value, /) | Return self+value. | | __and__(self, value, /) | Return self&value. | | __bool__(self, /) | self != 0 | | __divmod__(self, value, /) | Return divmod(self, value). | | __eq__(self, value, /) | Return self==value. | | __float__(self, /) | float(self) | | __floordiv__(self, value, /) | Return self//value. | | __ge__(self, value, /) | Return self>=value. | | __gt__(self, value, /) | Return self>value. | | __hash__(self, /) | Return hash(self). | | __index__(self, /) | Return self converted to an integer, if self is suitable for use as an index into a list. | | __int__(self, /) | int(self) | | __invert__(self, /) | ~self | | __le__(self, value, /) | Return self<=value. | | __lshift__(self, value, /) | Return self<<value. | | __lt__(self, value, /) | Return self<value. | | __mod__(self, value, /) | Return self%value. | | __mul__(self, value, /) | Return self*value. | | __ne__(self, value, /) | Return self!=value. | | __neg__(self, /) | -self | | __or__(self, value, /) | Return self|value. | | __pos__(self, /) | +self | | __pow__(self, value, mod=None, /) | Return pow(self, value, mod). | | __radd__(self, value, /) | Return value+self. | | __rand__(self, value, /) | Return value&self. | | __rdivmod__(self, value, /) | Return divmod(value, self). | | __repr__(self, /) | Return repr(self). | | __rfloordiv__(self, value, /) | Return value//self. | | __rlshift__(self, value, /) | Return value<<self. | | __rmod__(self, value, /) | Return value%self. | | __rmul__(self, value, /) | Return value*self. | | __ror__(self, value, /) | Return value|self. | | __rpow__(self, value, mod=None, /) | Return pow(value, self, mod). | | __rrshift__(self, value, /) | Return value>>self. | | __rshift__(self, value, /) | Return self>>value. | | __rsub__(self, value, /) | Return value-self. | | __rtruediv__(self, value, /) | Return value/self. | | __rxor__(self, value, /) | Return value^self. | | __str__(self, /) | Return str(self). | | __sub__(self, value, /) | Return self-value. | | __truediv__(self, value, /) | Return self/value. | | __xor__(self, value, /) | Return self^value. | | ---------------------------------------------------------------------- | Static methods defined here: | | __new__(*args, **kwargs) from builtins.type | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Methods inherited from integer: | | __round__(...) | | ---------------------------------------------------------------------- | Data descriptors inherited from integer: | | denominator | denominator of value (1) | | numerator | numerator of value (the value itself) | | ---------------------------------------------------------------------- | Methods inherited from generic: | | __array__(...) | sc.__array__(dtype) return 0-dim array from scalar with specified dtype | | __array_wrap__(...) | sc.__array_wrap__(obj) return scalar from array | | __copy__(...) | | __deepcopy__(...) | | __format__(...) | NumPy array scalar formatter | | __getitem__(self, key, /) | Return self[key]. | | __reduce__(...) | Helper for pickle. | | __setstate__(...) | | __sizeof__(...) | Size of object in memory, in bytes. | | all(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | getfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | base | base object | | data | pointer to start of data | | dtype | get array data-descriptor | | flags | integer value of flags | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension class int64(signedinteger) | Signed integer type, compatible with Python `int` anc C ``long``. | Character code: ``'l'``. | Canonical name: ``np.int_``. | Alias *on this platform*: ``np.int64``: 64-bit signed integer (-9223372036854775808 to 9223372036854775807). | Alias *on this platform*: ``np.intp``: Signed integer large enough to fit pointer, compatible with C ``intptr_t``. | | Method resolution order: | int64 | signedinteger | integer | number | generic | builtins.object | | Methods defined here: | | __abs__(self, /) | abs(self) | | __add__(self, value, /) | Return self+value. | | __and__(self, value, /) | Return self&value. | | __bool__(self, /) | self != 0 | | __divmod__(self, value, /) | Return divmod(self, value). | | __eq__(self, value, /) | Return self==value. | | __float__(self, /) | float(self) | | __floordiv__(self, value, /) | Return self//value. | | __ge__(self, value, /) | Return self>=value. | | __gt__(self, value, /) | Return self>value. | | __hash__(self, /) | Return hash(self). | | __index__(self, /) | Return self converted to an integer, if self is suitable for use as an index into a list. | | __int__(self, /) | int(self) | | __invert__(self, /) | ~self | | __le__(self, value, /) | Return self<=value. | | __lshift__(self, value, /) | Return self<<value. | | __lt__(self, value, /) | Return self<value. | | __mod__(self, value, /) | Return self%value. | | __mul__(self, value, /) | Return self*value. | | __ne__(self, value, /) | Return self!=value. | | __neg__(self, /) | -self | | __or__(self, value, /) | Return self|value. | | __pos__(self, /) | +self | | __pow__(self, value, mod=None, /) | Return pow(self, value, mod). | | __radd__(self, value, /) | Return value+self. | | __rand__(self, value, /) | Return value&self. | | __rdivmod__(self, value, /) | Return divmod(value, self). | | __repr__(self, /) | Return repr(self). | | __rfloordiv__(self, value, /) | Return value//self. | | __rlshift__(self, value, /) | Return value<<self. | | __rmod__(self, value, /) | Return value%self. | | __rmul__(self, value, /) | Return value*self. | | __ror__(self, value, /) | Return value|self. | | __rpow__(self, value, mod=None, /) | Return pow(value, self, mod). | | __rrshift__(self, value, /) | Return value>>self. | | __rshift__(self, value, /) | Return self>>value. | | __rsub__(self, value, /) | Return value-self. | | __rtruediv__(self, value, /) | Return value/self. | | __rxor__(self, value, /) | Return value^self. | | __str__(self, /) | Return str(self). | | __sub__(self, value, /) | Return self-value. | | __truediv__(self, value, /) | Return self/value. | | __xor__(self, value, /) | Return self^value. | | ---------------------------------------------------------------------- | Static methods defined here: | | __new__(*args, **kwargs) from builtins.type | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Methods inherited from integer: | | __round__(...) | | ---------------------------------------------------------------------- | Data descriptors inherited from integer: | | denominator | denominator of value (1) | | numerator | numerator of value (the value itself) | | ---------------------------------------------------------------------- | Methods inherited from generic: | | __array__(...) | sc.__array__(dtype) return 0-dim array from scalar with specified dtype | | __array_wrap__(...) | sc.__array_wrap__(obj) return scalar from array | | __copy__(...) | | __deepcopy__(...) | | __format__(...) | NumPy array scalar formatter | | __getitem__(self, key, /) | Return self[key]. | | __reduce__(...) | Helper for pickle. | | __setstate__(...) | | __sizeof__(...) | Size of object in memory, in bytes. | | all(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | getfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | base | base object | | data | pointer to start of data | | dtype | get array data-descriptor | | flags | integer value of flags | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension class int8(signedinteger) | Signed integer type, compatible with C ``char``. | Character code: ``'b'``. | Canonical name: ``np.byte``. | Alias *on this platform*: ``np.int8``: 8-bit signed integer (-128 to 127). | | Method resolution order: | int8 | signedinteger | integer | number | generic | builtins.object | | Methods defined here: | | __abs__(self, /) | abs(self) | | __add__(self, value, /) | Return self+value. | | __and__(self, value, /) | Return self&value. | | __bool__(self, /) | self != 0 | | __divmod__(self, value, /) | Return divmod(self, value). | | __eq__(self, value, /) | Return self==value. | | __float__(self, /) | float(self) | | __floordiv__(self, value, /) | Return self//value. | | __ge__(self, value, /) | Return self>=value. | | __gt__(self, value, /) | Return self>value. | | __hash__(self, /) | Return hash(self). | | __index__(self, /) | Return self converted to an integer, if self is suitable for use as an index into a list. | | __int__(self, /) | int(self) | | __invert__(self, /) | ~self | | __le__(self, value, /) | Return self<=value. | | __lshift__(self, value, /) | Return self<<value. | | __lt__(self, value, /) | Return self<value. | | __mod__(self, value, /) | Return self%value. | | __mul__(self, value, /) | Return self*value. | | __ne__(self, value, /) | Return self!=value. | | __neg__(self, /) | -self | | __or__(self, value, /) | Return self|value. | | __pos__(self, /) | +self | | __pow__(self, value, mod=None, /) | Return pow(self, value, mod). | | __radd__(self, value, /) | Return value+self. | | __rand__(self, value, /) | Return value&self. | | __rdivmod__(self, value, /) | Return divmod(value, self). | | __repr__(self, /) | Return repr(self). | | __rfloordiv__(self, value, /) | Return value//self. | | __rlshift__(self, value, /) | Return value<<self. | | __rmod__(self, value, /) | Return value%self. | | __rmul__(self, value, /) | Return value*self. | | __ror__(self, value, /) | Return value|self. | | __rpow__(self, value, mod=None, /) | Return pow(value, self, mod). | | __rrshift__(self, value, /) | Return value>>self. | | __rshift__(self, value, /) | Return self>>value. | | __rsub__(self, value, /) | Return value-self. | | __rtruediv__(self, value, /) | Return value/self. | | __rxor__(self, value, /) | Return value^self. | | __str__(self, /) | Return str(self). | | __sub__(self, value, /) | Return self-value. | | __truediv__(self, value, /) | Return self/value. | | __xor__(self, value, /) | Return self^value. | | ---------------------------------------------------------------------- | Static methods defined here: | | __new__(*args, **kwargs) from builtins.type | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Methods inherited from integer: | | __round__(...) | | ---------------------------------------------------------------------- | Data descriptors inherited from integer: | | denominator | denominator of value (1) | | numerator | numerator of value (the value itself) | | ---------------------------------------------------------------------- | Methods inherited from generic: | | __array__(...) | sc.__array__(dtype) return 0-dim array from scalar with specified dtype | | __array_wrap__(...) | sc.__array_wrap__(obj) return scalar from array | | __copy__(...) | | __deepcopy__(...) | | __format__(...) | NumPy array scalar formatter | | __getitem__(self, key, /) | Return self[key]. | | __reduce__(...) | Helper for pickle. | | __setstate__(...) | | __sizeof__(...) | Size of object in memory, in bytes. | | all(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | getfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | base | base object | | data | pointer to start of data | | dtype | get array data-descriptor | | flags | integer value of flags | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension int_ = class int64(signedinteger) | Signed integer type, compatible with Python `int` anc C ``long``. | Character code: ``'l'``. | Canonical name: ``np.int_``. | Alias *on this platform*: ``np.int64``: 64-bit signed integer (-9223372036854775808 to 9223372036854775807). | Alias *on this platform*: ``np.intp``: Signed integer large enough to fit pointer, compatible with C ``intptr_t``. | | Method resolution order: | int64 | signedinteger | integer | number | generic | builtins.object | | Methods defined here: | | __abs__(self, /) | abs(self) | | __add__(self, value, /) | Return self+value. | | __and__(self, value, /) | Return self&value. | | __bool__(self, /) | self != 0 | | __divmod__(self, value, /) | Return divmod(self, value). | | __eq__(self, value, /) | Return self==value. | | __float__(self, /) | float(self) | | __floordiv__(self, value, /) | Return self//value. | | __ge__(self, value, /) | Return self>=value. | | __gt__(self, value, /) | Return self>value. | | __hash__(self, /) | Return hash(self). | | __index__(self, /) | Return self converted to an integer, if self is suitable for use as an index into a list. | | __int__(self, /) | int(self) | | __invert__(self, /) | ~self | | __le__(self, value, /) | Return self<=value. | | __lshift__(self, value, /) | Return self<<value. | | __lt__(self, value, /) | Return self<value. | | __mod__(self, value, /) | Return self%value. | | __mul__(self, value, /) | Return self*value. | | __ne__(self, value, /) | Return self!=value. | | __neg__(self, /) | -self | | __or__(self, value, /) | Return self|value. | | __pos__(self, /) | +self | | __pow__(self, value, mod=None, /) | Return pow(self, value, mod). | | __radd__(self, value, /) | Return value+self. | | __rand__(self, value, /) | Return value&self. | | __rdivmod__(self, value, /) | Return divmod(value, self). | | __repr__(self, /) | Return repr(self). | | __rfloordiv__(self, value, /) | Return value//self. | | __rlshift__(self, value, /) | Return value<<self. | | __rmod__(self, value, /) | Return value%self. | | __rmul__(self, value, /) | Return value*self. | | __ror__(self, value, /) | Return value|self. | | __rpow__(self, value, mod=None, /) | Return pow(value, self, mod). | | __rrshift__(self, value, /) | Return value>>self. | | __rshift__(self, value, /) | Return self>>value. | | __rsub__(self, value, /) | Return value-self. | | __rtruediv__(self, value, /) | Return value/self. | | __rxor__(self, value, /) | Return value^self. | | __str__(self, /) | Return str(self). | | __sub__(self, value, /) | Return self-value. | | __truediv__(self, value, /) | Return self/value. | | __xor__(self, value, /) | Return self^value. | | ---------------------------------------------------------------------- | Static methods defined here: | | __new__(*args, **kwargs) from builtins.type | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Methods inherited from integer: | | __round__(...) | | ---------------------------------------------------------------------- | Data descriptors inherited from integer: | | denominator | denominator of value (1) | | numerator | numerator of value (the value itself) | | ---------------------------------------------------------------------- | Methods inherited from generic: | | __array__(...) | sc.__array__(dtype) return 0-dim array from scalar with specified dtype | | __array_wrap__(...) | sc.__array_wrap__(obj) return scalar from array | | __copy__(...) | | __deepcopy__(...) | | __format__(...) | NumPy array scalar formatter | | __getitem__(self, key, /) | Return self[key]. | | __reduce__(...) | Helper for pickle. | | __setstate__(...) | | __sizeof__(...) | Size of object in memory, in bytes. | | all(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | getfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | base | base object | | data | pointer to start of data | | dtype | get array data-descriptor | | flags | integer value of flags | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension intc = class int32(signedinteger) | Signed integer type, compatible with C ``int``. | Character code: ``'i'``. | Canonical name: ``np.intc``. | Alias *on this platform*: ``np.int32``: 32-bit signed integer (-2147483648 to 2147483647). | | Method resolution order: | int32 | signedinteger | integer | number | generic | builtins.object | | Methods defined here: | | __abs__(self, /) | abs(self) | | __add__(self, value, /) | Return self+value. | | __and__(self, value, /) | Return self&value. | | __bool__(self, /) | self != 0 | | __divmod__(self, value, /) | Return divmod(self, value). | | __eq__(self, value, /) | Return self==value. | | __float__(self, /) | float(self) | | __floordiv__(self, value, /) | Return self//value. | | __ge__(self, value, /) | Return self>=value. | | __gt__(self, value, /) | Return self>value. | | __hash__(self, /) | Return hash(self). | | __index__(self, /) | Return self converted to an integer, if self is suitable for use as an index into a list. | | __int__(self, /) | int(self) | | __invert__(self, /) | ~self | | __le__(self, value, /) | Return self<=value. | | __lshift__(self, value, /) | Return self<<value. | | __lt__(self, value, /) | Return self<value. | | __mod__(self, value, /) | Return self%value. | | __mul__(self, value, /) | Return self*value. | | __ne__(self, value, /) | Return self!=value. | | __neg__(self, /) | -self | | __or__(self, value, /) | Return self|value. | | __pos__(self, /) | +self | | __pow__(self, value, mod=None, /) | Return pow(self, value, mod). | | __radd__(self, value, /) | Return value+self. | | __rand__(self, value, /) | Return value&self. | | __rdivmod__(self, value, /) | Return divmod(value, self). | | __repr__(self, /) | Return repr(self). | | __rfloordiv__(self, value, /) | Return value//self. | | __rlshift__(self, value, /) | Return value<<self. | | __rmod__(self, value, /) | Return value%self. | | __rmul__(self, value, /) | Return value*self. | | __ror__(self, value, /) | Return value|self. | | __rpow__(self, value, mod=None, /) | Return pow(value, self, mod). | | __rrshift__(self, value, /) | Return value>>self. | | __rshift__(self, value, /) | Return self>>value. | | __rsub__(self, value, /) | Return value-self. | | __rtruediv__(self, value, /) | Return value/self. | | __rxor__(self, value, /) | Return value^self. | | __str__(self, /) | Return str(self). | | __sub__(self, value, /) | Return self-value. | | __truediv__(self, value, /) | Return self/value. | | __xor__(self, value, /) | Return self^value. | | ---------------------------------------------------------------------- | Static methods defined here: | | __new__(*args, **kwargs) from builtins.type | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Methods inherited from integer: | | __round__(...) | | ---------------------------------------------------------------------- | Data descriptors inherited from integer: | | denominator | denominator of value (1) | | numerator | numerator of value (the value itself) | | ---------------------------------------------------------------------- | Methods inherited from generic: | | __array__(...) | sc.__array__(dtype) return 0-dim array from scalar with specified dtype | | __array_wrap__(...) | sc.__array_wrap__(obj) return scalar from array | | __copy__(...) | | __deepcopy__(...) | | __format__(...) | NumPy array scalar formatter | | __getitem__(self, key, /) | Return self[key]. | | __reduce__(...) | Helper for pickle. | | __setstate__(...) | | __sizeof__(...) | Size of object in memory, in bytes. | | all(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | getfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | base | base object | | data | pointer to start of data | | dtype | get array data-descriptor | | flags | integer value of flags | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension class integer(number) | Abstract base class of all integer scalar types. | | Method resolution order: | integer | number | generic | builtins.object | | Methods defined here: | | __round__(...) | | ---------------------------------------------------------------------- | Data descriptors defined here: | | denominator | denominator of value (1) | | numerator | numerator of value (the value itself) | | ---------------------------------------------------------------------- | Methods inherited from generic: | | __abs__(self, /) | abs(self) | | __add__(self, value, /) | Return self+value. | | __and__(self, value, /) | Return self&value. | | __array__(...) | sc.__array__(dtype) return 0-dim array from scalar with specified dtype | | __array_wrap__(...) | sc.__array_wrap__(obj) return scalar from array | | __bool__(self, /) | self != 0 | | __copy__(...) | | __deepcopy__(...) | | __divmod__(self, value, /) | Return divmod(self, value). | | __eq__(self, value, /) | Return self==value. | | __float__(self, /) | float(self) | | __floordiv__(self, value, /) | Return self//value. | | __format__(...) | NumPy array scalar formatter | | __ge__(self, value, /) | Return self>=value. | | __getitem__(self, key, /) | Return self[key]. | | __gt__(self, value, /) | Return self>value. | | __int__(self, /) | int(self) | | __invert__(self, /) | ~self | | __le__(self, value, /) | Return self<=value. | | __lshift__(self, value, /) | Return self<<value. | | __lt__(self, value, /) | Return self<value. | | __mod__(self, value, /) | Return self%value. | | __mul__(self, value, /) | Return self*value. | | __ne__(self, value, /) | Return self!=value. | | __neg__(self, /) | -self | | __or__(self, value, /) | Return self|value. | | __pos__(self, /) | +self | | __pow__(self, value, mod=None, /) | Return pow(self, value, mod). | | __radd__(self, value, /) | Return value+self. | | __rand__(self, value, /) | Return value&self. | | __rdivmod__(self, value, /) | Return divmod(value, self). | | __reduce__(...) | Helper for pickle. | | __rfloordiv__(self, value, /) | Return value//self. | | __rlshift__(self, value, /) | Return value<<self. | | __rmod__(self, value, /) | Return value%self. | | __rmul__(self, value, /) | Return value*self. | | __ror__(self, value, /) | Return value|self. | | __rpow__(self, value, mod=None, /) | Return pow(value, self, mod). | | __rrshift__(self, value, /) | Return value>>self. | | __rshift__(self, value, /) | Return self>>value. | | __rsub__(self, value, /) | Return value-self. | | __rtruediv__(self, value, /) | Return value/self. | | __rxor__(self, value, /) | Return value^self. | | __setstate__(...) | | __sizeof__(...) | Size of object in memory, in bytes. | | __sub__(self, value, /) | Return self-value. | | __truediv__(self, value, /) | Return self/value. | | __xor__(self, value, /) | Return self^value. | | all(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | getfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | base | base object | | data | pointer to start of data | | dtype | get array data-descriptor | | flags | integer value of flags | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension | | ---------------------------------------------------------------------- | Data and other attributes inherited from generic: | | __hash__ = None intp = class int64(signedinteger) | Signed integer type, compatible with Python `int` anc C ``long``. | Character code: ``'l'``. | Canonical name: ``np.int_``. | Alias *on this platform*: ``np.int64``: 64-bit signed integer (-9223372036854775808 to 9223372036854775807). | Alias *on this platform*: ``np.intp``: Signed integer large enough to fit pointer, compatible with C ``intptr_t``. | | Method resolution order: | int64 | signedinteger | integer | number | generic | builtins.object | | Methods defined here: | | __abs__(self, /) | abs(self) | | __add__(self, value, /) | Return self+value. | | __and__(self, value, /) | Return self&value. | | __bool__(self, /) | self != 0 | | __divmod__(self, value, /) | Return divmod(self, value). | | __eq__(self, value, /) | Return self==value. | | __float__(self, /) | float(self) | | __floordiv__(self, value, /) | Return self//value. | | __ge__(self, value, /) | Return self>=value. | | __gt__(self, value, /) | Return self>value. | | __hash__(self, /) | Return hash(self). | | __index__(self, /) | Return self converted to an integer, if self is suitable for use as an index into a list. | | __int__(self, /) | int(self) | | __invert__(self, /) | ~self | | __le__(self, value, /) | Return self<=value. | | __lshift__(self, value, /) | Return self<<value. | | __lt__(self, value, /) | Return self<value. | | __mod__(self, value, /) | Return self%value. | | __mul__(self, value, /) | Return self*value. | | __ne__(self, value, /) | Return self!=value. | | __neg__(self, /) | -self | | __or__(self, value, /) | Return self|value. | | __pos__(self, /) | +self | | __pow__(self, value, mod=None, /) | Return pow(self, value, mod). | | __radd__(self, value, /) | Return value+self. | | __rand__(self, value, /) | Return value&self. | | __rdivmod__(self, value, /) | Return divmod(value, self). | | __repr__(self, /) | Return repr(self). | | __rfloordiv__(self, value, /) | Return value//self. | | __rlshift__(self, value, /) | Return value<<self. | | __rmod__(self, value, /) | Return value%self. | | __rmul__(self, value, /) | Return value*self. | | __ror__(self, value, /) | Return value|self. | | __rpow__(self, value, mod=None, /) | Return pow(value, self, mod). | | __rrshift__(self, value, /) | Return value>>self. | | __rshift__(self, value, /) | Return self>>value. | | __rsub__(self, value, /) | Return value-self. | | __rtruediv__(self, value, /) | Return value/self. | | __rxor__(self, value, /) | Return value^self. | | __str__(self, /) | Return str(self). | | __sub__(self, value, /) | Return self-value. | | __truediv__(self, value, /) | Return self/value. | | __xor__(self, value, /) | Return self^value. | | ---------------------------------------------------------------------- | Static methods defined here: | | __new__(*args, **kwargs) from builtins.type | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Methods inherited from integer: | | __round__(...) | | ---------------------------------------------------------------------- | Data descriptors inherited from integer: | | denominator | denominator of value (1) | | numerator | numerator of value (the value itself) | | ---------------------------------------------------------------------- | Methods inherited from generic: | | __array__(...) | sc.__array__(dtype) return 0-dim array from scalar with specified dtype | | __array_wrap__(...) | sc.__array_wrap__(obj) return scalar from array | | __copy__(...) | | __deepcopy__(...) | | __format__(...) | NumPy array scalar formatter | | __getitem__(self, key, /) | Return self[key]. | | __reduce__(...) | Helper for pickle. | | __setstate__(...) | | __sizeof__(...) | Size of object in memory, in bytes. | | all(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | getfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | base | base object | | data | pointer to start of data | | dtype | get array data-descriptor | | flags | integer value of flags | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension longcomplex = class complex256(complexfloating) | Complex number type composed of two extended-precision floating-point | numbers. | Character code: ``'G'``. | Canonical name: ``np.clongdouble``. | Alias: ``np.clongfloat``. | Alias: ``np.longcomplex``. | Alias *on this platform*: ``np.complex256``: Complex number type composed of 2 128-bit extended-precision floating-point numbers. | | Method resolution order: | complex256 | complexfloating | inexact | number | generic | builtins.object | | Methods defined here: | | __abs__(self, /) | abs(self) | | __add__(self, value, /) | Return self+value. | | __bool__(self, /) | self != 0 | | __complex__(...) | | __eq__(self, value, /) | Return self==value. | | __float__(self, /) | float(self) | | __floordiv__(self, value, /) | Return self//value. | | __ge__(self, value, /) | Return self>=value. | | __gt__(self, value, /) | Return self>value. | | __hash__(self, /) | Return hash(self). | | __int__(self, /) | int(self) | | __le__(self, value, /) | Return self<=value. | | __lt__(self, value, /) | Return self<value. | | __mul__(self, value, /) | Return self*value. | | __ne__(self, value, /) | Return self!=value. | | __neg__(self, /) | -self | | __pos__(self, /) | +self | | __pow__(self, value, mod=None, /) | Return pow(self, value, mod). | | __radd__(self, value, /) | Return value+self. | | __repr__(self, /) | Return repr(self). | | __rfloordiv__(self, value, /) | Return value//self. | | __rmul__(self, value, /) | Return value*self. | | __rpow__(self, value, mod=None, /) | Return pow(value, self, mod). | | __rsub__(self, value, /) | Return value-self. | | __rtruediv__(self, value, /) | Return value/self. | | __str__(self, /) | Return str(self). | | __sub__(self, value, /) | Return self-value. | | __truediv__(self, value, /) | Return self/value. | | ---------------------------------------------------------------------- | Static methods defined here: | | __new__(*args, **kwargs) from builtins.type | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Methods inherited from complexfloating: | | __round__(...) | | ---------------------------------------------------------------------- | Methods inherited from generic: | | __and__(self, value, /) | Return self&value. | | __array__(...) | sc.__array__(dtype) return 0-dim array from scalar with specified dtype | | __array_wrap__(...) | sc.__array_wrap__(obj) return scalar from array | | __copy__(...) | | __deepcopy__(...) | | __divmod__(self, value, /) | Return divmod(self, value). | | __format__(...) | NumPy array scalar formatter | | __getitem__(self, key, /) | Return self[key]. | | __invert__(self, /) | ~self | | __lshift__(self, value, /) | Return self<<value. | | __mod__(self, value, /) | Return self%value. | | __or__(self, value, /) | Return self|value. | | __rand__(self, value, /) | Return value&self. | | __rdivmod__(self, value, /) | Return divmod(value, self). | | __reduce__(...) | Helper for pickle. | | __rlshift__(self, value, /) | Return value<<self. | | __rmod__(self, value, /) | Return value%self. | | __ror__(self, value, /) | Return value|self. | | __rrshift__(self, value, /) | Return value>>self. | | __rshift__(self, value, /) | Return self>>value. | | __rxor__(self, value, /) | Return value^self. | | __setstate__(...) | | __sizeof__(...) | Size of object in memory, in bytes. | | __xor__(self, value, /) | Return self^value. | | all(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | getfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | base | base object | | data | pointer to start of data | | dtype | get array data-descriptor | | flags | integer value of flags | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension longdouble = class float128(floating) | Extended-precision floating-point number type, compatible with C | ``long double`` but not necessarily with IEEE 754 quadruple-precision. | Character code: ``'g'``. | Canonical name: ``np.longdouble``. | Alias: ``np.longfloat``. | Alias *on this platform*: ``np.float128``: 128-bit extended-precision floating-point number type. | | Method resolution order: | float128 | floating | inexact | number | generic | builtins.object | | Methods defined here: | | __abs__(self, /) | abs(self) | | __add__(self, value, /) | Return self+value. | | __bool__(self, /) | self != 0 | | __divmod__(self, value, /) | Return divmod(self, value). | | __eq__(self, value, /) | Return self==value. | | __float__(self, /) | float(self) | | __floordiv__(self, value, /) | Return self//value. | | __ge__(self, value, /) | Return self>=value. | | __gt__(self, value, /) | Return self>value. | | __hash__(self, /) | Return hash(self). | | __int__(self, /) | int(self) | | __le__(self, value, /) | Return self<=value. | | __lt__(self, value, /) | Return self<value. | | __mod__(self, value, /) | Return self%value. | | __mul__(self, value, /) | Return self*value. | | __ne__(self, value, /) | Return self!=value. | | __neg__(self, /) | -self | | __pos__(self, /) | +self | | __pow__(self, value, mod=None, /) | Return pow(self, value, mod). | | __radd__(self, value, /) | Return value+self. | | __rdivmod__(self, value, /) | Return divmod(value, self). | | __repr__(self, /) | Return repr(self). | | __rfloordiv__(self, value, /) | Return value//self. | | __rmod__(self, value, /) | Return value%self. | | __rmul__(self, value, /) | Return value*self. | | __rpow__(self, value, mod=None, /) | Return pow(value, self, mod). | | __rsub__(self, value, /) | Return value-self. | | __rtruediv__(self, value, /) | Return value/self. | | __str__(self, /) | Return str(self). | | __sub__(self, value, /) | Return self-value. | | __truediv__(self, value, /) | Return self/value. | | as_integer_ratio(...) | longdouble.as_integer_ratio() -> (int, int) | | Return a pair of integers, whose ratio is exactly equal to the original | floating point number, and with a positive denominator. | Raise OverflowError on infinities and a ValueError on NaNs. | | >>> np.longdouble(10.0).as_integer_ratio() | (10, 1) | >>> np.longdouble(0.0).as_integer_ratio() | (0, 1) | >>> np.longdouble(-.25).as_integer_ratio() | (-1, 4) | | ---------------------------------------------------------------------- | Static methods defined here: | | __new__(*args, **kwargs) from builtins.type | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Methods inherited from floating: | | __round__(...) | | ---------------------------------------------------------------------- | Methods inherited from generic: | | __and__(self, value, /) | Return self&value. | | __array__(...) | sc.__array__(dtype) return 0-dim array from scalar with specified dtype | | __array_wrap__(...) | sc.__array_wrap__(obj) return scalar from array | | __copy__(...) | | __deepcopy__(...) | | __format__(...) | NumPy array scalar formatter | | __getitem__(self, key, /) | Return self[key]. | | __invert__(self, /) | ~self | | __lshift__(self, value, /) | Return self<<value. | | __or__(self, value, /) | Return self|value. | | __rand__(self, value, /) | Return value&self. | | __reduce__(...) | Helper for pickle. | | __rlshift__(self, value, /) | Return value<<self. | | __ror__(self, value, /) | Return value|self. | | __rrshift__(self, value, /) | Return value>>self. | | __rshift__(self, value, /) | Return self>>value. | | __rxor__(self, value, /) | Return value^self. | | __setstate__(...) | | __sizeof__(...) | Size of object in memory, in bytes. | | __xor__(self, value, /) | Return self^value. | | all(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | getfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | base | base object | | data | pointer to start of data | | dtype | get array data-descriptor | | flags | integer value of flags | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension longfloat = class float128(floating) | Extended-precision floating-point number type, compatible with C | ``long double`` but not necessarily with IEEE 754 quadruple-precision. | Character code: ``'g'``. | Canonical name: ``np.longdouble``. | Alias: ``np.longfloat``. | Alias *on this platform*: ``np.float128``: 128-bit extended-precision floating-point number type. | | Method resolution order: | float128 | floating | inexact | number | generic | builtins.object | | Methods defined here: | | __abs__(self, /) | abs(self) | | __add__(self, value, /) | Return self+value. | | __bool__(self, /) | self != 0 | | __divmod__(self, value, /) | Return divmod(self, value). | | __eq__(self, value, /) | Return self==value. | | __float__(self, /) | float(self) | | __floordiv__(self, value, /) | Return self//value. | | __ge__(self, value, /) | Return self>=value. | | __gt__(self, value, /) | Return self>value. | | __hash__(self, /) | Return hash(self). | | __int__(self, /) | int(self) | | __le__(self, value, /) | Return self<=value. | | __lt__(self, value, /) | Return self<value. | | __mod__(self, value, /) | Return self%value. | | __mul__(self, value, /) | Return self*value. | | __ne__(self, value, /) | Return self!=value. | | __neg__(self, /) | -self | | __pos__(self, /) | +self | | __pow__(self, value, mod=None, /) | Return pow(self, value, mod). | | __radd__(self, value, /) | Return value+self. | | __rdivmod__(self, value, /) | Return divmod(value, self). | | __repr__(self, /) | Return repr(self). | | __rfloordiv__(self, value, /) | Return value//self. | | __rmod__(self, value, /) | Return value%self. | | __rmul__(self, value, /) | Return value*self. | | __rpow__(self, value, mod=None, /) | Return pow(value, self, mod). | | __rsub__(self, value, /) | Return value-self. | | __rtruediv__(self, value, /) | Return value/self. | | __str__(self, /) | Return str(self). | | __sub__(self, value, /) | Return self-value. | | __truediv__(self, value, /) | Return self/value. | | as_integer_ratio(...) | longdouble.as_integer_ratio() -> (int, int) | | Return a pair of integers, whose ratio is exactly equal to the original | floating point number, and with a positive denominator. | Raise OverflowError on infinities and a ValueError on NaNs. | | >>> np.longdouble(10.0).as_integer_ratio() | (10, 1) | >>> np.longdouble(0.0).as_integer_ratio() | (0, 1) | >>> np.longdouble(-.25).as_integer_ratio() | (-1, 4) | | ---------------------------------------------------------------------- | Static methods defined here: | | __new__(*args, **kwargs) from builtins.type | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Methods inherited from floating: | | __round__(...) | | ---------------------------------------------------------------------- | Methods inherited from generic: | | __and__(self, value, /) | Return self&value. | | __array__(...) | sc.__array__(dtype) return 0-dim array from scalar with specified dtype | | __array_wrap__(...) | sc.__array_wrap__(obj) return scalar from array | | __copy__(...) | | __deepcopy__(...) | | __format__(...) | NumPy array scalar formatter | | __getitem__(self, key, /) | Return self[key]. | | __invert__(self, /) | ~self | | __lshift__(self, value, /) | Return self<<value. | | __or__(self, value, /) | Return self|value. | | __rand__(self, value, /) | Return value&self. | | __reduce__(...) | Helper for pickle. | | __rlshift__(self, value, /) | Return value<<self. | | __ror__(self, value, /) | Return value|self. | | __rrshift__(self, value, /) | Return value>>self. | | __rshift__(self, value, /) | Return self>>value. | | __rxor__(self, value, /) | Return value^self. | | __setstate__(...) | | __sizeof__(...) | Size of object in memory, in bytes. | | __xor__(self, value, /) | Return self^value. | | all(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | getfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | base | base object | | data | pointer to start of data | | dtype | get array data-descriptor | | flags | integer value of flags | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension class longlong(signedinteger) | Signed integer type, compatible with C ``long long``. | Character code: ``'q'``. | | Method resolution order: | longlong | signedinteger | integer | number | generic | builtins.object | | Methods defined here: | | __abs__(self, /) | abs(self) | | __add__(self, value, /) | Return self+value. | | __and__(self, value, /) | Return self&value. | | __bool__(self, /) | self != 0 | | __divmod__(self, value, /) | Return divmod(self, value). | | __eq__(self, value, /) | Return self==value. | | __float__(self, /) | float(self) | | __floordiv__(self, value, /) | Return self//value. | | __ge__(self, value, /) | Return self>=value. | | __gt__(self, value, /) | Return self>value. | | __hash__(self, /) | Return hash(self). | | __index__(self, /) | Return self converted to an integer, if self is suitable for use as an index into a list. | | __int__(self, /) | int(self) | | __invert__(self, /) | ~self | | __le__(self, value, /) | Return self<=value. | | __lshift__(self, value, /) | Return self<<value. | | __lt__(self, value, /) | Return self<value. | | __mod__(self, value, /) | Return self%value. | | __mul__(self, value, /) | Return self*value. | | __ne__(self, value, /) | Return self!=value. | | __neg__(self, /) | -self | | __or__(self, value, /) | Return self|value. | | __pos__(self, /) | +self | | __pow__(self, value, mod=None, /) | Return pow(self, value, mod). | | __radd__(self, value, /) | Return value+self. | | __rand__(self, value, /) | Return value&self. | | __rdivmod__(self, value, /) | Return divmod(value, self). | | __repr__(self, /) | Return repr(self). | | __rfloordiv__(self, value, /) | Return value//self. | | __rlshift__(self, value, /) | Return value<<self. | | __rmod__(self, value, /) | Return value%self. | | __rmul__(self, value, /) | Return value*self. | | __ror__(self, value, /) | Return value|self. | | __rpow__(self, value, mod=None, /) | Return pow(value, self, mod). | | __rrshift__(self, value, /) | Return value>>self. | | __rshift__(self, value, /) | Return self>>value. | | __rsub__(self, value, /) | Return value-self. | | __rtruediv__(self, value, /) | Return value/self. | | __rxor__(self, value, /) | Return value^self. | | __str__(self, /) | Return str(self). | | __sub__(self, value, /) | Return self-value. | | __truediv__(self, value, /) | Return self/value. | | __xor__(self, value, /) | Return self^value. | | ---------------------------------------------------------------------- | Static methods defined here: | | __new__(*args, **kwargs) from builtins.type | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Methods inherited from integer: | | __round__(...) | | ---------------------------------------------------------------------- | Data descriptors inherited from integer: | | denominator | denominator of value (1) | | numerator | numerator of value (the value itself) | | ---------------------------------------------------------------------- | Methods inherited from generic: | | __array__(...) | sc.__array__(dtype) return 0-dim array from scalar with specified dtype | | __array_wrap__(...) | sc.__array_wrap__(obj) return scalar from array | | __copy__(...) | | __deepcopy__(...) | | __format__(...) | NumPy array scalar formatter | | __getitem__(self, key, /) | Return self[key]. | | __reduce__(...) | Helper for pickle. | | __setstate__(...) | | __sizeof__(...) | Size of object in memory, in bytes. | | all(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | getfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | base | base object | | data | pointer to start of data | | dtype | get array data-descriptor | | flags | integer value of flags | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension class matrix(ndarray) | matrix(data, dtype=None, copy=True) | | matrix(data, dtype=None, copy=True) | | .. note:: It is no longer recommended to use this class, even for linear | algebra. Instead use regular arrays. The class may be removed | in the future. | | Returns a matrix from an array-like object, or from a string of data. | A matrix is a specialized 2-D array that retains its 2-D nature | through operations. It has certain special operators, such as ``*`` | (matrix multiplication) and ``**`` (matrix power). | | Parameters | ---------- | data : array_like or string | If `data` is a string, it is interpreted as a matrix with commas | or spaces separating columns, and semicolons separating rows. | dtype : data-type | Data-type of the output matrix. | copy : bool | If `data` is already an `ndarray`, then this flag determines | whether the data is copied (the default), or whether a view is | constructed. | | See Also | -------- | array | | Examples | -------- | >>> a = np.matrix('1 2; 3 4') | >>> a | matrix([[1, 2], | [3, 4]]) | | >>> np.matrix([[1, 2], [3, 4]]) | matrix([[1, 2], | [3, 4]]) | | Method resolution order: | matrix | ndarray | builtins.object | | Methods defined here: | | __array_finalize__(self, obj) | None. | | __getitem__(self, index) | Return self[key]. | | __imul__(self, other) | Return self*=value. | | __ipow__(self, other) | Return self**=value. | | __mul__(self, other) | Return self*value. | | __pow__(self, other) | Return pow(self, value, mod). | | __rmul__(self, other) | Return value*self. | | __rpow__(self, other) | Return pow(value, self, mod). | | all(self, axis=None, out=None) | Test whether all matrix elements along a given axis evaluate to True. | | Parameters | ---------- | See `numpy.all` for complete descriptions | | See Also | -------- | numpy.all | | Notes | ----- | This is the same as `ndarray.all`, but it returns a `matrix` object. | | Examples | -------- | >>> x = np.matrix(np.arange(12).reshape((3,4))); x | matrix([[ 0, 1, 2, 3], | [ 4, 5, 6, 7], | [ 8, 9, 10, 11]]) | >>> y = x[0]; y | matrix([[0, 1, 2, 3]]) | >>> (x == y) | matrix([[ True, True, True, True], | [False, False, False, False], | [False, False, False, False]]) | >>> (x == y).all() | False | >>> (x == y).all(0) | matrix([[False, False, False, False]]) | >>> (x == y).all(1) | matrix([[ True], | [False], | [False]]) | | any(self, axis=None, out=None) | Test whether any array element along a given axis evaluates to True. | | Refer to `numpy.any` for full documentation. | | Parameters | ---------- | axis : int, optional | Axis along which logical OR is performed | out : ndarray, optional | Output to existing array instead of creating new one, must have | same shape as expected output | | Returns | ------- | any : bool, ndarray | Returns a single bool if `axis` is ``None``; otherwise, | returns `ndarray` | | argmax(self, axis=None, out=None) | Indexes of the maximum values along an axis. | | Return the indexes of the first occurrences of the maximum values | along the specified axis. If axis is None, the index is for the | flattened matrix. | | Parameters | ---------- | See `numpy.argmax` for complete descriptions | | See Also | -------- | numpy.argmax | | Notes | ----- | This is the same as `ndarray.argmax`, but returns a `matrix` object | where `ndarray.argmax` would return an `ndarray`. | | Examples | -------- | >>> x = np.matrix(np.arange(12).reshape((3,4))); x | matrix([[ 0, 1, 2, 3], | [ 4, 5, 6, 7], | [ 8, 9, 10, 11]]) | >>> x.argmax() | 11 | >>> x.argmax(0) | matrix([[2, 2, 2, 2]]) | >>> x.argmax(1) | matrix([[3], | [3], | [3]]) | | argmin(self, axis=None, out=None) | Indexes of the minimum values along an axis. | | Return the indexes of the first occurrences of the minimum values | along the specified axis. If axis is None, the index is for the | flattened matrix. | | Parameters | ---------- | See `numpy.argmin` for complete descriptions. | | See Also | -------- | numpy.argmin | | Notes | ----- | This is the same as `ndarray.argmin`, but returns a `matrix` object | where `ndarray.argmin` would return an `ndarray`. | | Examples | -------- | >>> x = -np.matrix(np.arange(12).reshape((3,4))); x | matrix([[ 0, -1, -2, -3], | [ -4, -5, -6, -7], | [ -8, -9, -10, -11]]) | >>> x.argmin() | 11 | >>> x.argmin(0) | matrix([[2, 2, 2, 2]]) | >>> x.argmin(1) | matrix([[3], | [3], | [3]]) | | flatten(self, order='C') | Return a flattened copy of the matrix. | | All `N` elements of the matrix are placed into a single row. | | Parameters | ---------- | order : {'C', 'F', 'A', 'K'}, optional | 'C' means to flatten in row-major (C-style) order. 'F' means to | flatten in column-major (Fortran-style) order. 'A' means to | flatten in column-major order if `m` is Fortran *contiguous* in | memory, row-major order otherwise. 'K' means to flatten `m` in | the order the elements occur in memory. The default is 'C'. | | Returns | ------- | y : matrix | A copy of the matrix, flattened to a `(1, N)` matrix where `N` | is the number of elements in the original matrix. | | See Also | -------- | ravel : Return a flattened array. | flat : A 1-D flat iterator over the matrix. | | Examples | -------- | >>> m = np.matrix([[1,2], [3,4]]) | >>> m.flatten() | matrix([[1, 2, 3, 4]]) | >>> m.flatten('F') | matrix([[1, 3, 2, 4]]) | | getA = A(self) | Return `self` as an `ndarray` object. | | Equivalent to ``np.asarray(self)``. | | Parameters | ---------- | None | | Returns | ------- | ret : ndarray | `self` as an `ndarray` | | Examples | -------- | >>> x = np.matrix(np.arange(12).reshape((3,4))); x | matrix([[ 0, 1, 2, 3], | [ 4, 5, 6, 7], | [ 8, 9, 10, 11]]) | >>> x.getA() | array([[ 0, 1, 2, 3], | [ 4, 5, 6, 7], | [ 8, 9, 10, 11]]) | | getA1 = A1(self) | Return `self` as a flattened `ndarray`. | | Equivalent to ``np.asarray(x).ravel()`` | | Parameters | ---------- | None | | Returns | ------- | ret : ndarray | `self`, 1-D, as an `ndarray` | | Examples | -------- | >>> x = np.matrix(np.arange(12).reshape((3,4))); x | matrix([[ 0, 1, 2, 3], | [ 4, 5, 6, 7], | [ 8, 9, 10, 11]]) | >>> x.getA1() | array([ 0, 1, 2, ..., 9, 10, 11]) | | getH = H(self) | Returns the (complex) conjugate transpose of `self`. | | Equivalent to ``np.transpose(self)`` if `self` is real-valued. | | Parameters | ---------- | None | | Returns | ------- | ret : matrix object | complex conjugate transpose of `self` | | Examples | -------- | >>> x = np.matrix(np.arange(12).reshape((3,4))) | >>> z = x - 1j*x; z | matrix([[ 0. +0.j, 1. -1.j, 2. -2.j, 3. -3.j], | [ 4. -4.j, 5. -5.j, 6. -6.j, 7. -7.j], | [ 8. -8.j, 9. -9.j, 10.-10.j, 11.-11.j]]) | >>> z.getH() | matrix([[ 0. -0.j, 4. +4.j, 8. +8.j], | [ 1. +1.j, 5. +5.j, 9. +9.j], | [ 2. +2.j, 6. +6.j, 10.+10.j], | [ 3. +3.j, 7. +7.j, 11.+11.j]]) | | getI = I(self) | Returns the (multiplicative) inverse of invertible `self`. | | Parameters | ---------- | None | | Returns | ------- | ret : matrix object | If `self` is non-singular, `ret` is such that ``ret * self`` == | ``self * ret`` == ``np.matrix(np.eye(self[0,:].size))`` all return | ``True``. | | Raises | ------ | numpy.linalg.LinAlgError: Singular matrix | If `self` is singular. | | See Also | -------- | linalg.inv | | Examples | -------- | >>> m = np.matrix('[1, 2; 3, 4]'); m | matrix([[1, 2], | [3, 4]]) | >>> m.getI() | matrix([[-2. , 1. ], | [ 1.5, -0.5]]) | >>> m.getI() * m | matrix([[ 1., 0.], # may vary | [ 0., 1.]]) | | getT = T(self) | Returns the transpose of the matrix. | | Does *not* conjugate! For the complex conjugate transpose, use ``.H``. | | Parameters | ---------- | None | | Returns | ------- | ret : matrix object | The (non-conjugated) transpose of the matrix. | | See Also | -------- | transpose, getH | | Examples | -------- | >>> m = np.matrix('[1, 2; 3, 4]') | >>> m | matrix([[1, 2], | [3, 4]]) | >>> m.getT() | matrix([[1, 3], | [2, 4]]) | | max(self, axis=None, out=None) | Return the maximum value along an axis. | | Parameters | ---------- | See `amax` for complete descriptions | | See Also | -------- | amax, ndarray.max | | Notes | ----- | This is the same as `ndarray.max`, but returns a `matrix` object | where `ndarray.max` would return an ndarray. | | Examples | -------- | >>> x = np.matrix(np.arange(12).reshape((3,4))); x | matrix([[ 0, 1, 2, 3], | [ 4, 5, 6, 7], | [ 8, 9, 10, 11]]) | >>> x.max() | 11 | >>> x.max(0) | matrix([[ 8, 9, 10, 11]]) | >>> x.max(1) | matrix([[ 3], | [ 7], | [11]]) | | mean(self, axis=None, dtype=None, out=None) | Returns the average of the matrix elements along the given axis. | | Refer to `numpy.mean` for full documentation. | | See Also | -------- | numpy.mean | | Notes | ----- | Same as `ndarray.mean` except that, where that returns an `ndarray`, | this returns a `matrix` object. | | Examples | -------- | >>> x = np.matrix(np.arange(12).reshape((3, 4))) | >>> x | matrix([[ 0, 1, 2, 3], | [ 4, 5, 6, 7], | [ 8, 9, 10, 11]]) | >>> x.mean() | 5.5 | >>> x.mean(0) | matrix([[4., 5., 6., 7.]]) | >>> x.mean(1) | matrix([[ 1.5], | [ 5.5], | [ 9.5]]) | | min(self, axis=None, out=None) | Return the minimum value along an axis. | | Parameters | ---------- | See `amin` for complete descriptions. | | See Also | -------- | amin, ndarray.min | | Notes | ----- | This is the same as `ndarray.min`, but returns a `matrix` object | where `ndarray.min` would return an ndarray. | | Examples | -------- | >>> x = -np.matrix(np.arange(12).reshape((3,4))); x | matrix([[ 0, -1, -2, -3], | [ -4, -5, -6, -7], | [ -8, -9, -10, -11]]) | >>> x.min() | -11 | >>> x.min(0) | matrix([[ -8, -9, -10, -11]]) | >>> x.min(1) | matrix([[ -3], | [ -7], | [-11]]) | | prod(self, axis=None, dtype=None, out=None) | Return the product of the array elements over the given axis. | | Refer to `prod` for full documentation. | | See Also | -------- | prod, ndarray.prod | | Notes | ----- | Same as `ndarray.prod`, except, where that returns an `ndarray`, this | returns a `matrix` object instead. | | Examples | -------- | >>> x = np.matrix(np.arange(12).reshape((3,4))); x | matrix([[ 0, 1, 2, 3], | [ 4, 5, 6, 7], | [ 8, 9, 10, 11]]) | >>> x.prod() | 0 | >>> x.prod(0) | matrix([[ 0, 45, 120, 231]]) | >>> x.prod(1) | matrix([[ 0], | [ 840], | [7920]]) | | ptp(self, axis=None, out=None) | Peak-to-peak (maximum - minimum) value along the given axis. | | Refer to `numpy.ptp` for full documentation. | | See Also | -------- | numpy.ptp | | Notes | ----- | Same as `ndarray.ptp`, except, where that would return an `ndarray` object, | this returns a `matrix` object. | | Examples | -------- | >>> x = np.matrix(np.arange(12).reshape((3,4))); x | matrix([[ 0, 1, 2, 3], | [ 4, 5, 6, 7], | [ 8, 9, 10, 11]]) | >>> x.ptp() | 11 | >>> x.ptp(0) | matrix([[8, 8, 8, 8]]) | >>> x.ptp(1) | matrix([[3], | [3], | [3]]) | | ravel(self, order='C') | Return a flattened matrix. | | Refer to `numpy.ravel` for more documentation. | | Parameters | ---------- | order : {'C', 'F', 'A', 'K'}, optional | The elements of `m` are read using this index order. 'C' means to | index the elements in C-like order, with the last axis index | changing fastest, back to the first axis index changing slowest. | 'F' means to index the elements in Fortran-like index order, with | the first index changing fastest, and the last index changing | slowest. Note that the 'C' and 'F' options take no account of the | memory layout of the underlying array, and only refer to the order | of axis indexing. 'A' means to read the elements in Fortran-like | index order if `m` is Fortran *contiguous* in memory, C-like order | otherwise. 'K' means to read the elements in the order they occur | in memory, except for reversing the data when strides are negative. | By default, 'C' index order is used. | | Returns | ------- | ret : matrix | Return the matrix flattened to shape `(1, N)` where `N` | is the number of elements in the original matrix. | A copy is made only if necessary. | | See Also | -------- | matrix.flatten : returns a similar output matrix but always a copy | matrix.flat : a flat iterator on the array. | numpy.ravel : related function which returns an ndarray | | squeeze(self, axis=None) | Return a possibly reshaped matrix. | | Refer to `numpy.squeeze` for more documentation. | | Parameters | ---------- | axis : None or int or tuple of ints, optional | Selects a subset of the single-dimensional entries in the shape. | If an axis is selected with shape entry greater than one, | an error is raised. | | Returns | ------- | squeezed : matrix | The matrix, but as a (1, N) matrix if it had shape (N, 1). | | See Also | -------- | numpy.squeeze : related function | | Notes | ----- | If `m` has a single column then that column is returned | as the single row of a matrix. Otherwise `m` is returned. | The returned matrix is always either `m` itself or a view into `m`. | Supplying an axis keyword argument will not affect the returned matrix | but it may cause an error to be raised. | | Examples | -------- | >>> c = np.matrix([[1], [2]]) | >>> c | matrix([[1], | [2]]) | >>> c.squeeze() | matrix([[1, 2]]) | >>> r = c.T | >>> r | matrix([[1, 2]]) | >>> r.squeeze() | matrix([[1, 2]]) | >>> m = np.matrix([[1, 2], [3, 4]]) | >>> m.squeeze() | matrix([[1, 2], | [3, 4]]) | | std(self, axis=None, dtype=None, out=None, ddof=0) | Return the standard deviation of the array elements along the given axis. | | Refer to `numpy.std` for full documentation. | | See Also | -------- | numpy.std | | Notes | ----- | This is the same as `ndarray.std`, except that where an `ndarray` would | be returned, a `matrix` object is returned instead. | | Examples | -------- | >>> x = np.matrix(np.arange(12).reshape((3, 4))) | >>> x | matrix([[ 0, 1, 2, 3], | [ 4, 5, 6, 7], | [ 8, 9, 10, 11]]) | >>> x.std() | 3.4520525295346629 # may vary | >>> x.std(0) | matrix([[ 3.26598632, 3.26598632, 3.26598632, 3.26598632]]) # may vary | >>> x.std(1) | matrix([[ 1.11803399], | [ 1.11803399], | [ 1.11803399]]) | | sum(self, axis=None, dtype=None, out=None) | Returns the sum of the matrix elements, along the given axis. | | Refer to `numpy.sum` for full documentation. | | See Also | -------- | numpy.sum | | Notes | ----- | This is the same as `ndarray.sum`, except that where an `ndarray` would | be returned, a `matrix` object is returned instead. | | Examples | -------- | >>> x = np.matrix([[1, 2], [4, 3]]) | >>> x.sum() | 10 | >>> x.sum(axis=1) | matrix([[3], | [7]]) | >>> x.sum(axis=1, dtype='float') | matrix([[3.], | [7.]]) | >>> out = np.zeros((2, 1), dtype='float') | >>> x.sum(axis=1, dtype='float', out=np.asmatrix(out)) | matrix([[3.], | [7.]]) | | tolist(self) | Return the matrix as a (possibly nested) list. | | See `ndarray.tolist` for full documentation. | | See Also | -------- | ndarray.tolist | | Examples | -------- | >>> x = np.matrix(np.arange(12).reshape((3,4))); x | matrix([[ 0, 1, 2, 3], | [ 4, 5, 6, 7], | [ 8, 9, 10, 11]]) | >>> x.tolist() | [[0, 1, 2, 3], [4, 5, 6, 7], [8, 9, 10, 11]] | | var(self, axis=None, dtype=None, out=None, ddof=0) | Returns the variance of the matrix elements, along the given axis. | | Refer to `numpy.var` for full documentation. | | See Also | -------- | numpy.var | | Notes | ----- | This is the same as `ndarray.var`, except that where an `ndarray` would | be returned, a `matrix` object is returned instead. | | Examples | -------- | >>> x = np.matrix(np.arange(12).reshape((3, 4))) | >>> x | matrix([[ 0, 1, 2, 3], | [ 4, 5, 6, 7], | [ 8, 9, 10, 11]]) | >>> x.var() | 11.916666666666666 | >>> x.var(0) | matrix([[ 10.66666667, 10.66666667, 10.66666667, 10.66666667]]) # may vary | >>> x.var(1) | matrix([[1.25], | [1.25], | [1.25]]) | | ---------------------------------------------------------------------- | Static methods defined here: | | __new__(subtype, data, dtype=None, copy=True) | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Readonly properties defined here: | | A | Return `self` as an `ndarray` object. | | Equivalent to ``np.asarray(self)``. | | Parameters | ---------- | None | | Returns | ------- | ret : ndarray | `self` as an `ndarray` | | Examples | -------- | >>> x = np.matrix(np.arange(12).reshape((3,4))); x | matrix([[ 0, 1, 2, 3], | [ 4, 5, 6, 7], | [ 8, 9, 10, 11]]) | >>> x.getA() | array([[ 0, 1, 2, 3], | [ 4, 5, 6, 7], | [ 8, 9, 10, 11]]) | | A1 | Return `self` as a flattened `ndarray`. | | Equivalent to ``np.asarray(x).ravel()`` | | Parameters | ---------- | None | | Returns | ------- | ret : ndarray | `self`, 1-D, as an `ndarray` | | Examples | -------- | >>> x = np.matrix(np.arange(12).reshape((3,4))); x | matrix([[ 0, 1, 2, 3], | [ 4, 5, 6, 7], | [ 8, 9, 10, 11]]) | >>> x.getA1() | array([ 0, 1, 2, ..., 9, 10, 11]) | | H | Returns the (complex) conjugate transpose of `self`. | | Equivalent to ``np.transpose(self)`` if `self` is real-valued. | | Parameters | ---------- | None | | Returns | ------- | ret : matrix object | complex conjugate transpose of `self` | | Examples | -------- | >>> x = np.matrix(np.arange(12).reshape((3,4))) | >>> z = x - 1j*x; z | matrix([[ 0. +0.j, 1. -1.j, 2. -2.j, 3. -3.j], | [ 4. -4.j, 5. -5.j, 6. -6.j, 7. -7.j], | [ 8. -8.j, 9. -9.j, 10.-10.j, 11.-11.j]]) | >>> z.getH() | matrix([[ 0. -0.j, 4. +4.j, 8. +8.j], | [ 1. +1.j, 5. +5.j, 9. +9.j], | [ 2. +2.j, 6. +6.j, 10.+10.j], | [ 3. +3.j, 7. +7.j, 11.+11.j]]) | | I | Returns the (multiplicative) inverse of invertible `self`. | | Parameters | ---------- | None | | Returns | ------- | ret : matrix object | If `self` is non-singular, `ret` is such that ``ret * self`` == | ``self * ret`` == ``np.matrix(np.eye(self[0,:].size))`` all return | ``True``. | | Raises | ------ | numpy.linalg.LinAlgError: Singular matrix | If `self` is singular. | | See Also | -------- | linalg.inv | | Examples | -------- | >>> m = np.matrix('[1, 2; 3, 4]'); m | matrix([[1, 2], | [3, 4]]) | >>> m.getI() | matrix([[-2. , 1. ], | [ 1.5, -0.5]]) | >>> m.getI() * m | matrix([[ 1., 0.], # may vary | [ 0., 1.]]) | | T | Returns the transpose of the matrix. | | Does *not* conjugate! For the complex conjugate transpose, use ``.H``. | | Parameters | ---------- | None | | Returns | ------- | ret : matrix object | The (non-conjugated) transpose of the matrix. | | See Also | -------- | transpose, getH | | Examples | -------- | >>> m = np.matrix('[1, 2; 3, 4]') | >>> m | matrix([[1, 2], | [3, 4]]) | >>> m.getT() | matrix([[1, 3], | [2, 4]]) | | ---------------------------------------------------------------------- | Data descriptors defined here: | | __dict__ | dictionary for instance variables (if defined) | | ---------------------------------------------------------------------- | Data and other attributes defined here: | | __array_priority__ = 10.0 | | ---------------------------------------------------------------------- | Methods inherited from ndarray: | | __abs__(self, /) | abs(self) | | __add__(self, value, /) | Return self+value. | | __and__(self, value, /) | Return self&value. | | __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_function__(...) | | __array_prepare__(...) | a.__array_prepare__(obj) -> Object of same type as ndarray object obj. | | __array_ufunc__(...) | | __array_wrap__(...) | a.__array_wrap__(obj) -> Object of same type as ndarray object a. | | __bool__(self, /) | self != 0 | | __complex__(...) | | __contains__(self, key, /) | Return key in self. | | __copy__(...) | a.__copy__() | | Used if :func:`copy.copy` is called on an array. Returns a copy of the array. | | Equivalent to ``a.copy(order='K')``. | | __deepcopy__(...) | a.__deepcopy__(memo, /) -> Deep copy of array. | | Used if :func:`copy.deepcopy` is called on an array. | | __delitem__(self, key, /) | Delete self[key]. | | __divmod__(self, value, /) | Return divmod(self, value). | | __eq__(self, value, /) | Return self==value. | | __float__(self, /) | float(self) | | __floordiv__(self, value, /) | Return self//value. | | __format__(...) | Default object formatter. | | __ge__(self, value, /) | Return self>=value. | | __gt__(self, value, /) | Return self>value. | | __iadd__(self, value, /) | Return self+=value. | | __iand__(self, value, /) | Return self&=value. | | __ifloordiv__(self, value, /) | Return self//=value. | | __ilshift__(self, value, /) | Return self<<=value. | | __imatmul__(self, value, /) | Return self@=value. | | __imod__(self, value, /) | Return self%=value. | | __index__(self, /) | Return self converted to an integer, if self is suitable for use as an index into a list. | | __int__(self, /) | int(self) | | __invert__(self, /) | ~self | | __ior__(self, value, /) | Return self|=value. | | __irshift__(self, value, /) | Return self>>=value. | | __isub__(self, value, /) | Return self-=value. | | __iter__(self, /) | Implement iter(self). | | __itruediv__(self, value, /) | Return self/=value. | | __ixor__(self, value, /) | Return self^=value. | | __le__(self, value, /) | Return self<=value. | | __len__(self, /) | Return len(self). | | __lshift__(self, value, /) | Return self<<value. | | __lt__(self, value, /) | Return self<value. | | __matmul__(self, value, /) | Return self@value. | | __mod__(self, value, /) | Return self%value. | | __ne__(self, value, /) | Return self!=value. | | __neg__(self, /) | -self | | __or__(self, value, /) | Return self|value. | | __pos__(self, /) | +self | | __radd__(self, value, /) | Return value+self. | | __rand__(self, value, /) | Return value&self. | | __rdivmod__(self, value, /) | Return divmod(value, self). | | __reduce__(...) | a.__reduce__() | | For pickling. | | __reduce_ex__(...) | Helper for pickle. | | __repr__(self, /) | Return repr(self). | | __rfloordiv__(self, value, /) | Return value//self. | | __rlshift__(self, value, /) | Return value<<self. | | __rmatmul__(self, value, /) | Return value@self. | | __rmod__(self, value, /) | Return value%self. | | __ror__(self, value, /) | Return value|self. | | __rrshift__(self, value, /) | Return value>>self. | | __rshift__(self, value, /) | Return self>>value. | | __rsub__(self, value, /) | Return value-self. | | __rtruediv__(self, value, /) | Return value/self. | | __rxor__(self, value, /) | Return value^self. | | __setitem__(self, key, value, /) | Set self[key] to value. | | __setstate__(...) | a.__setstate__(state, /) | | For unpickling. | | The `state` argument must be a sequence that contains the following | elements: | | Parameters | ---------- | version : int | optional pickle version. If omitted defaults to 0. | shape : tuple | dtype : data-type | isFortran : bool | rawdata : string or list | a binary string with the data (or a list if 'a' is an object array) | | __sizeof__(...) | Size of object in memory, in bytes. | | __str__(self, /) | Return str(self). | | __sub__(self, value, /) | Return self-value. | | __truediv__(self, value, /) | Return self/value. | | __xor__(self, value, /) | Return self^value. | | argpartition(...) | a.argpartition(kth, axis=-1, kind='introselect', order=None) | | Returns the indices that would partition this array. | | Refer to `numpy.argpartition` for full documentation. | | .. versionadded:: 1.8.0 | | See Also | -------- | numpy.argpartition : equivalent function | | argsort(...) | a.argsort(axis=-1, kind=None, order=None) | | Returns the indices that would sort this array. | | Refer to `numpy.argsort` for full documentation. | | See Also | -------- | numpy.argsort : equivalent function | | astype(...) | a.astype(dtype, order='K', casting='unsafe', subok=True, copy=True) | | Copy of the array, cast to a specified type. | | Parameters | ---------- | dtype : str or dtype | Typecode or data-type to which the array is cast. | order : {'C', 'F', 'A', 'K'}, optional | Controls the memory layout order of the result. | 'C' means C order, 'F' means Fortran order, 'A' | means 'F' order if all the arrays are Fortran contiguous, | 'C' order otherwise, and 'K' means as close to the | order the array elements appear in memory as possible. | Default is 'K'. | casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional | Controls what kind of data casting may occur. Defaults to 'unsafe' | for backwards compatibility. | | * 'no' means the data types should not be cast at all. | * 'equiv' means only byte-order changes are allowed. | * 'safe' means only casts which can preserve values are allowed. | * 'same_kind' means only safe casts or casts within a kind, | like float64 to float32, are allowed. | * 'unsafe' means any data conversions may be done. | subok : bool, optional | If True, then sub-classes will be passed-through (default), otherwise | the returned array will be forced to be a base-class array. | copy : bool, optional | By default, astype always returns a newly allocated array. If this | is set to false, and the `dtype`, `order`, and `subok` | requirements are satisfied, the input array is returned instead | of a copy. | | Returns | ------- | arr_t : ndarray | Unless `copy` is False and the other conditions for returning the input | array are satisfied (see description for `copy` input parameter), `arr_t` | is a new array of the same shape as the input array, with dtype, order | given by `dtype`, `order`. | | Notes | ----- | .. versionchanged:: 1.17.0 | Casting between a simple data type and a structured one is possible only | for "unsafe" casting. Casting to multiple fields is allowed, but | casting from multiple fields is not. | | .. versionchanged:: 1.9.0 | Casting from numeric to string types in 'safe' casting mode requires | that the string dtype length is long enough to store the max | integer/float value converted. | | 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=False) | | 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. | Arrays of byte-strings are not swapped. The real and imaginary | parts of a complex number are swapped individually. | | 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) | >>> list(map(hex, A)) | ['0x1', '0x100', '0x2233'] | >>> A.byteswap(inplace=True) | array([ 256, 1, 13090], dtype=int16) | >>> list(map(hex, A)) | ['0x100', '0x1', '0x3322'] | | Arrays of byte-strings are not swapped | | >>> A = np.array([b'ceg', b'fac']) | >>> A.byteswap() | array([b'ceg', b'fac'], dtype='|S3') | | ``A.newbyteorder().byteswap()`` produces an array with the same values | but different representation in memory | | >>> A = np.array([1, 2, 3]) | >>> A.view(np.uint8) | array([1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, | 0, 0], dtype=uint8) | >>> A.newbyteorder().byteswap(inplace=True) | array([1, 2, 3]) | >>> A.view(np.uint8) | array([0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, | 0, 3], dtype=uint8) | | choose(...) | a.choose(choices, out=None, mode='raise') | | Use an index array to construct a new array from a set of choices. | | Refer to `numpy.choose` for full documentation. | | See Also | -------- | numpy.choose : equivalent function | | clip(...) | a.clip(min=None, max=None, out=None, **kwargs) | | Return an array whose values are limited to ``[min, max]``. | One of max or min must be given. | | Refer to `numpy.clip` for full documentation. | | See Also | -------- | numpy.clip : equivalent function | | compress(...) | a.compress(condition, axis=None, out=None) | | Return selected slices of this array along given axis. | | Refer to `numpy.compress` for full documentation. | | See Also | -------- | numpy.compress : equivalent function | | conj(...) | a.conj() | | Complex-conjugate all elements. | | Refer to `numpy.conjugate` for full documentation. | | See Also | -------- | numpy.conjugate : equivalent function | | conjugate(...) | a.conjugate() | | Return the complex conjugate, element-wise. | | Refer to `numpy.conjugate` for full documentation. | | See Also | -------- | numpy.conjugate : equivalent function | | copy(...) | a.copy(order='C') | | Return a copy of the array. | | Parameters | ---------- | order : {'C', 'F', 'A', 'K'}, optional | Controls the memory layout of the copy. 'C' means C-order, | 'F' means F-order, 'A' means 'F' if `a` is Fortran contiguous, | 'C' otherwise. 'K' means match the layout of `a` as closely | as possible. (Note that this function and :func:`numpy.copy` are very | similar, but have different default values for their order= | arguments.) | | See also | -------- | numpy.copy | numpy.copyto | | Examples | -------- | >>> x = np.array([[1,2,3],[4,5,6]], order='F') | | >>> y = x.copy() | | >>> x.fill(0) | | >>> x | array([[0, 0, 0], | [0, 0, 0]]) | | >>> y | array([[1, 2, 3], | [4, 5, 6]]) | | >>> y.flags['C_CONTIGUOUS'] | True | | cumprod(...) | a.cumprod(axis=None, dtype=None, out=None) | | Return the cumulative product of the elements along the given axis. | | Refer to `numpy.cumprod` for full documentation. | | See Also | -------- | numpy.cumprod : equivalent function | | cumsum(...) | a.cumsum(axis=None, dtype=None, out=None) | | Return the cumulative sum of the elements along the given axis. | | Refer to `numpy.cumsum` for full documentation. | | See Also | -------- | numpy.cumsum : equivalent function | | diagonal(...) | a.diagonal(offset=0, axis1=0, axis2=1) | | Return specified diagonals. In NumPy 1.9 the returned array is a | read-only view instead of a copy as in previous NumPy versions. In | a future version the read-only restriction will be removed. | | Refer to :func:`numpy.diagonal` for full documentation. | | See Also | -------- | numpy.diagonal : equivalent function | | dot(...) | a.dot(b, out=None) | | Dot product of two arrays. | | Refer to `numpy.dot` for full documentation. | | See Also | -------- | numpy.dot : equivalent function | | Examples | -------- | >>> a = np.eye(2) | >>> b = np.ones((2, 2)) * 2 | >>> a.dot(b) | array([[2., 2.], | [2., 2.]]) | | This array method can be conveniently chained: | | >>> a.dot(b).dot(b) | array([[8., 8.], | [8., 8.]]) | | dump(...) | a.dump(file) | | Dump a pickle of the array to the specified file. | The array can be read back with pickle.load or numpy.load. | | Parameters | ---------- | file : str or Path | A string naming the dump file. | | .. versionchanged:: 1.17.0 | `pathlib.Path` objects are now accepted. | | 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.]) | | getfield(...) | a.getfield(dtype, offset=0) | | Returns a field of the given array as a certain type. | | A field is a view of the array data with a given data-type. The values in | the view are determined by the given type and the offset into the current | array in bytes. The offset needs to be such that the view dtype fits in the | array dtype; for example an array of dtype complex128 has 16-byte elements. | If taking a view with a 32-bit integer (4 bytes), the offset needs to be | between 0 and 12 bytes. | | Parameters | ---------- | dtype : str or dtype | The data type of the view. The dtype size of the view can not be larger | than that of the array itself. | offset : int | Number of bytes to skip before beginning the element view. | | Examples | -------- | >>> x = np.diag([1.+1.j]*2) | >>> x[1, 1] = 2 + 4.j | >>> x | array([[1.+1.j, 0.+0.j], | [0.+0.j, 2.+4.j]]) | >>> x.getfield(np.float64) | array([[1., 0.], | [0., 2.]]) | | By choosing an offset of 8 bytes we can select the complex part of the | array for our view: | | >>> x.getfield(np.float64, offset=8) | array([[1., 0.], | [0., 4.]]) | | item(...) | a.item(*args) | | Copy an element of an array to a standard Python scalar and return it. | | Parameters | ---------- | \*args : Arguments (variable number and type) | | * none: in this case, the method only works for arrays | with one element (`a.size == 1`), which element is | copied into a standard Python scalar object and returned. | | * int_type: this argument is interpreted as a flat index into | the array, specifying which element to copy and return. | | * tuple of int_types: functions as does a single int_type argument, | except that the argument is interpreted as an nd-index into the | array. | | Returns | ------- | z : Standard Python scalar object | A copy of the specified element of the array as a suitable | Python scalar | | Notes | ----- | When the data type of `a` is longdouble or clongdouble, item() returns | a scalar array object because there is no available Python scalar that | would not lose information. Void arrays return a buffer object for item(), | unless fields are defined, in which case a tuple is returned. | | `item` is very similar to a[args], except, instead of an array scalar, | a standard Python scalar is returned. This can be useful for speeding up | access to elements of the array and doing arithmetic on elements of the | array using Python's optimized math. | | Examples | -------- | >>> np.random.seed(123) | >>> x = np.random.randint(9, size=(3, 3)) | >>> x | array([[2, 2, 6], | [1, 3, 6], | [1, 0, 1]]) | >>> x.item(3) | 1 | >>> x.item(7) | 0 | >>> x.item((0, 1)) | 2 | >>> x.item((2, 2)) | 1 | | 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 | -------- | >>> np.random.seed(123) | >>> x = np.random.randint(9, size=(3, 3)) | >>> x | array([[2, 2, 6], | [1, 3, 6], | [1, 0, 1]]) | >>> x.itemset(4, 0) | >>> x.itemset((2, 2), 9) | >>> x | array([[2, 2, 6], | [1, 0, 6], | [1, 0, 9]]) | | newbyteorder(...) | arr.newbyteorder(new_order='S') | | Return the array with the same data viewed with a different byte order. | | Equivalent to:: | | arr.view(arr.dtype.newbytorder(new_order)) | | Changes are also made in all fields and sub-arrays of the array data | type. | | | | Parameters | ---------- | new_order : string, optional | Byte order to force; a value from the byte order specifications | below. `new_order` codes can be any of: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_arr : array | New array object with the dtype reflecting given change to the | byte order. | | nonzero(...) | a.nonzero() | | Return the indices of the elements that are non-zero. | | Refer to `numpy.nonzero` for full documentation. | | See Also | -------- | numpy.nonzero : equivalent function | | partition(...) | a.partition(kth, axis=-1, kind='introselect', order=None) | | Rearranges the elements in the array in such a way that the value of the | element in kth position is in the position it would be in a sorted array. | All elements smaller than the kth element are moved before this element and | all equal or greater are moved behind it. The ordering of the elements in | the two partitions is undefined. | | .. versionadded:: 1.8.0 | | Parameters | ---------- | kth : int or sequence of ints | Element index to partition by. The kth element value will be in its | final sorted position and all smaller elements will be moved before it | and all equal or greater elements behind it. | The order of all elements in the partitions is undefined. | If provided with a sequence of kth it will partition all elements | indexed by kth of them into their sorted position at once. | axis : int, optional | Axis along which to sort. Default is -1, which means sort along the | last axis. | kind : {'introselect'}, optional | Selection algorithm. Default is 'introselect'. | order : str or list of str, optional | When `a` is an array with fields defined, this argument specifies | which fields to compare first, second, etc. A single field can | be specified as a string, and not all fields need to be specified, | but unspecified fields will still be used, in the order in which | they come up in the dtype, to break ties. | | See Also | -------- | numpy.partition : Return a parititioned copy of an array. | argpartition : Indirect partition. | sort : Full sort. | | Notes | ----- | See ``np.partition`` for notes on the different algorithms. | | Examples | -------- | >>> a = np.array([3, 4, 2, 1]) | >>> a.partition(3) | >>> a | array([2, 1, 3, 4]) | | >>> a.partition((1, 3)) | >>> a | array([1, 2, 3, 4]) | | 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 | | 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 | | Notes | ----- | Unlike the free function `numpy.reshape`, this method on `ndarray` allows | the elements of the shape parameter to be passed in as separate arguments. | For example, ``a.reshape(10, 11)`` is equivalent to | ``a.reshape((10, 11))``. | | 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. | PyPy only: will always raise if the data memory must be changed, since | there is no reliable way to determine if references or views to it | exist. | | 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 references or is 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]], dtype=int32) | >>> x | array([[1.0e+000, 1.5e-323, 1.5e-323], | [1.5e-323, 1.0e+000, 1.5e-323], | [1.5e-323, 1.5e-323, 1.0e+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, (WRITEBACKIFCOPY 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 WRITEBACKIFCOPY and (deprecated) UPDATEIFCOPY flags 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 7 Boolean flags | in use, only four of which can be changed by the user: | WRITEBACKIFCOPY, 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) (deprecated), replaced by WRITEBACKIFCOPY; | | WRITEBACKIFCOPY (X) this array is a copy of some other array (referenced | by .base). When the C-API function PyArray_ResolveWritebackIfCopy is | called, the base array will be updated with the contents of this array. | | All flags can be accessed using the single (upper case) letter as well | as the full name. | | Examples | -------- | >>> y = np.array([[3, 1, 7], | ... [2, 0, 0], | ... [8, 5, 9]]) | >>> 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 | WRITEBACKIFCOPY : False | UPDATEIFCOPY : False | >>> y.setflags(write=0, align=0) | >>> y.flags | C_CONTIGUOUS : True | F_CONTIGUOUS : False | OWNDATA : True | WRITEABLE : False | ALIGNED : False | WRITEBACKIFCOPY : False | UPDATEIFCOPY : False | >>> y.setflags(uic=1) | Traceback (most recent call last): | File "<stdin>", line 1, in <module> | ValueError: cannot set WRITEBACKIFCOPY flag to True | | sort(...) | a.sort(axis=-1, kind=None, order=None) | | Sort an array in-place. Refer to `numpy.sort` for full documentation. | | Parameters | ---------- | axis : int, optional | Axis along which to sort. Default is -1, which means sort along the | last axis. | kind : {'quicksort', 'mergesort', 'heapsort', 'stable'}, optional | Sorting algorithm. The default is 'quicksort'. Note that both 'stable' | and 'mergesort' use timsort under the covers and, in general, the | actual implementation will vary with datatype. The 'mergesort' option | is retained for backwards compatibility. | | .. versionchanged:: 1.15.0. | The 'stable' option was added. | | order : str or list of str, optional | When `a` is an array with fields defined, this argument specifies | which fields to compare first, second, etc. A single field can | be specified as a string, and not all fields need be specified, | but unspecified fields will still be used, in the order in which | they come up in the dtype, to break ties. | | See Also | -------- | numpy.sort : Return a sorted copy of an array. | numpy.argsort : Indirect sort. | numpy.lexsort : Indirect stable sort on multiple keys. | numpy.searchsorted : Find elements in sorted array. | numpy.partition: Partial sort. | | Notes | ----- | See `numpy.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([(b'c', 1), (b'a', 2)], | dtype=[('x', 'S1'), ('y', '<i8')]) | | swapaxes(...) | a.swapaxes(axis1, axis2) | | Return a view of the array with `axis1` and `axis2` interchanged. | | Refer to `numpy.swapaxes` for full documentation. | | See Also | -------- | numpy.swapaxes : equivalent function | | take(...) | a.take(indices, axis=None, out=None, mode='raise') | | Return an array formed from the elements of `a` at the given indices. | | Refer to `numpy.take` for full documentation. | | See Also | -------- | numpy.take : equivalent function | | tobytes(...) | a.tobytes(order='C') | | Construct Python bytes containing the raw data bytes in the array. | | Constructs Python bytes showing a copy of the raw contents of | data memory. The bytes object can be produced in either 'C' or 'Fortran', | or 'Any' order (the default is 'C'-order). 'Any' order means C-order | unless the F_CONTIGUOUS flag in the array is set, in which case it | means 'Fortran' order. | | .. versionadded:: 1.9.0 | | Parameters | ---------- | order : {'C', 'F', None}, optional | Order of the data for multidimensional arrays: | C, Fortran, or the same as for the original array. | | Returns | ------- | s : bytes | Python bytes exhibiting a copy of `a`'s raw data. | | Examples | -------- | >>> x = np.array([[0, 1], [2, 3]], dtype='<u2') | >>> x.tobytes() | b'\x00\x00\x01\x00\x02\x00\x03\x00' | >>> x.tobytes('C') == x.tobytes() | True | >>> x.tobytes('F') | b'\x00\x00\x02\x00\x01\x00\x03\x00' | | tofile(...) | a.tofile(fid, sep="", format="%s") | | Write array to a file as text or binary (default). | | Data is always written in 'C' order, independent of the order of `a`. | The data produced by this method can be recovered using the function | fromfile(). | | Parameters | ---------- | fid : file or str or Path | An open file object, or a string containing a filename. | | .. versionchanged:: 1.17.0 | `pathlib.Path` objects are now accepted. | | sep : str | Separator between array items for text output. | If "" (empty), a binary file is written, equivalent to | ``file.write(a.tobytes())``. | format : str | Format string for text file output. | Each entry in the array is formatted to text by first converting | it to the closest Python type, and then using "format" % item. | | Notes | ----- | This is a convenience function for quick storage of array data. | Information on endianness and precision is lost, so this method is not a | good choice for files intended to archive data or transport data between | machines with different endianness. Some of these problems can be overcome | by outputting the data as text files, at the expense of speed and file | size. | | When fid is a file object, array contents are directly written to the | file, bypassing the file object's ``write`` method. As a result, tofile | cannot be used with files objects supporting compression (e.g., GzipFile) | or file-like objects that do not support ``fileno()`` (e.g., BytesIO). | | tostring(...) | a.tostring(order='C') | | A compatibility alias for `tobytes`, with exactly the same behavior. | | Despite its name, it returns `bytes` not `str`\ s. | | .. deprecated:: 1.19.0 | | 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, as a transposed vector is simply the | same vector. To convert a 1-D array into a 2D column vector, an additional | dimension must be added. `np.atleast2d(a).T` achieves this, as does | `a[:, np.newaxis]`. | For a 2-D array, this is a standard 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. | ndarray.reshape : Give a new shape to an array without changing its data. | | 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]]) | | view(...) | a.view([dtype][, type]) | | New view of array with the same data. | | .. note:: | Passing None for ``dtype`` is different from omitting the parameter, | since the former invokes ``dtype(None)`` which is an alias for | ``dtype('float_')``. | | Parameters | ---------- | dtype : data-type or ndarray sub-class, optional | Data-type descriptor of the returned view, e.g., float32 or int16. | Omitting it 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, omission | of the parameter 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.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 | >>> x | array([(1, 20), (3, 4)], dtype=[('a', 'i1'), ('b', 'i1')]) | | Using a view to convert an array to a recarray: | | >>> z = x.view(np.recarray) | >>> z.a | array([1, 3], 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): | ... | ValueError: To change to a dtype of a different size, the array must be C-contiguous | >>> z = y.copy() | >>> z.view(dtype=[('width', np.int16), ('length', np.int16)]) | array([[(1, 2)], | [(4, 5)]], dtype=[('width', '<i2'), ('length', '<i2')]) | | ---------------------------------------------------------------------- | Data descriptors inherited from ndarray: | | __array_interface__ | Array protocol: Python side. | | __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): | | .. autoattribute:: numpy.core._internal._ctypes.data | :noindex: | | .. autoattribute:: numpy.core._internal._ctypes.shape | :noindex: | | .. autoattribute:: numpy.core._internal._ctypes.strides | :noindex: | | .. automethod:: numpy.core._internal._ctypes.data_as | :noindex: | | .. automethod:: numpy.core._internal._ctypes.shape_as | :noindex: | | .. automethod:: numpy.core._internal._ctypes.strides_as | :noindex: | | 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 = np.array([[0, 1], [2, 3]], dtype=np.int32) | >>> x | array([[0, 1], | [2, 3]], dtype=int32) | >>> x.ctypes.data | 31962608 # may vary | >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_uint32)) | <__main__.LP_c_uint object at 0x7ff2fc1fc200> # may vary | >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_uint32)).contents | c_uint(0) | >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_uint64)).contents | c_ulong(4294967296) | >>> x.ctypes.shape | <numpy.core._internal.c_long_Array_2 object at 0x7ff2fc1fce60> # may vary | >>> x.ctypes.strides | <numpy.core._internal.c_long_Array_2 object at 0x7ff2fc1ff320> # may vary | | 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. | WRITEBACKIFCOPY (X) | This array is a copy of some other array. The C-API function | PyArray_ResolveWritebackIfCopy must be called before deallocating | to the base array will be updated with the contents of this array. | UPDATEIFCOPY (U) | (Deprecated, use WRITEBACKIFCOPY) 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 WRITEBACKIFCOPY, 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``. | - WRITEBACKIFCOPY 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) | <class '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. | | The shape property is usually used to get the current shape of an array, | but may also be used to reshape the array in-place by assigning a tuple of | array dimensions to it. As with `numpy.reshape`, one of the new shape | dimensions can be -1, in which case its value is inferred from the size of | the array and the remaining dimensions. Reshaping an array in-place will | fail if a copy is required. | | 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 | >>> np.zeros((4,2))[::2].shape = (-1,) | Traceback (most recent call last): | File "<stdin>", line 1, in <module> | AttributeError: Incompatible shape for in-place modification. Use | `.reshape()` to make a copy with the desired shape. | | See Also | -------- | numpy.reshape : similar function | ndarray.reshape : similar method | | size | Number of elements in the array. | | Equal to ``np.prod(a.shape)``, i.e., the product of the array's | dimensions. | | Notes | ----- | `a.size` returns a standard arbitrary precision Python integer. This | may not be the case with other methods of obtaining the same value | (like the suggested ``np.prod(a.shape)``, which returns an instance | of ``np.int_``), and may be relevant if the value is used further in | calculations that may overflow a fixed size integer type. | | Examples | -------- | >>> x = np.zeros((3, 5, 2), dtype=np.complex128) | >>> x.size | 30 | >>> np.prod(x.shape) | 30 | | strides | Tuple of bytes to step in each dimension when traversing an array. | | The byte offset of element ``(i[0], i[1], ..., i[n])`` in an array `a` | is:: | | offset = sum(np.array(i) * a.strides) | | A more detailed explanation of strides can be found in the | "ndarray.rst" file in the NumPy reference guide. | | Notes | ----- | Imagine an array of 32-bit integers (each 4 bytes):: | | x = np.array([[0, 1, 2, 3, 4], | [5, 6, 7, 8, 9]], dtype=np.int32) | | This array is stored in memory as 40 bytes, one after the other | (known as a contiguous block of memory). The strides of an array tell | us how many bytes we have to skip in memory to move to the next position | along a certain axis. For example, we have to skip 4 bytes (1 value) to | move to the next column, but 20 bytes (5 values) to get to the same | position in the next row. As such, the strides for the array `x` will be | ``(20, 4)``. | | See Also | -------- | numpy.lib.stride_tricks.as_strided | | Examples | -------- | >>> y = np.reshape(np.arange(2*3*4), (2,3,4)) | >>> y | array([[[ 0, 1, 2, 3], | [ 4, 5, 6, 7], | [ 8, 9, 10, 11]], | [[12, 13, 14, 15], | [16, 17, 18, 19], | [20, 21, 22, 23]]]) | >>> y.strides | (48, 16, 4) | >>> y[1,1,1] | 17 | >>> offset=sum(y.strides * np.array((1,1,1))) | >>> offset/y.itemsize | 17 | | >>> x = np.reshape(np.arange(5*6*7*8), (5,6,7,8)).transpose(2,3,1,0) | >>> x.strides | (32, 4, 224, 1344) | >>> i = np.array([3,5,2,2]) | >>> offset = sum(i * x.strides) | >>> x[3,5,2,2] | 813 | >>> offset / x.itemsize | 813 | | ---------------------------------------------------------------------- | Data and other attributes inherited from ndarray: | | __hash__ = None class memmap(ndarray) | memmap(filename, dtype=<class 'numpy.uint8'>, mode='r+', offset=0, shape=None, order='C') | | Create a memory-map to an array stored in a *binary* file on disk. | | Memory-mapped files are used for accessing small segments of large files | on disk, without reading the entire file into memory. NumPy's | memmap's are array-like objects. This differs from Python's ``mmap`` | module, which uses file-like objects. | | This subclass of ndarray has some unpleasant interactions with | some operations, because it doesn't quite fit properly as a subclass. | An alternative to using this subclass is to create the ``mmap`` | object yourself, then create an ndarray with ndarray.__new__ directly, | passing the object created in its 'buffer=' parameter. | | This class may at some point be turned into a factory function | which returns a view into an mmap buffer. | | Delete the memmap instance to close the memmap file. | | | Parameters | ---------- | filename : str, file-like object, or pathlib.Path instance | The file name or file object to be used as the array data buffer. | dtype : data-type, optional | The data-type used to interpret the file contents. | Default is `uint8`. | mode : {'r+', 'r', 'w+', 'c'}, optional | The file is opened in this mode: | | +------+-------------------------------------------------------------+ | | 'r' | Open existing file for reading only. | | +------+-------------------------------------------------------------+ | | 'r+' | Open existing file for reading and writing. | | +------+-------------------------------------------------------------+ | | 'w+' | Create or overwrite existing file for reading and writing. | | +------+-------------------------------------------------------------+ | | 'c' | Copy-on-write: assignments affect data in memory, but | | | | changes are not saved to disk. The file on disk is | | | | read-only. | | +------+-------------------------------------------------------------+ | | Default is 'r+'. | offset : int, optional | In the file, array data starts at this offset. Since `offset` is | measured in bytes, it should normally be a multiple of the byte-size | of `dtype`. When ``mode != 'r'``, even positive offsets beyond end of | file are valid; The file will be extended to accommodate the | additional data. By default, ``memmap`` will start at the beginning of | the file, even if ``filename`` is a file pointer ``fp`` and | ``fp.tell() != 0``. | shape : tuple, optional | The desired shape of the array. If ``mode == 'r'`` and the number | of remaining bytes after `offset` is not a multiple of the byte-size | of `dtype`, you must specify `shape`. By default, the returned array | will be 1-D with the number of elements determined by file size | and data-type. | order : {'C', 'F'}, optional | Specify the order of the ndarray memory layout: | :term:`row-major`, C-style or :term:`column-major`, | Fortran-style. This only has an effect if the shape is | greater than 1-D. The default order is 'C'. | | Attributes | ---------- | filename : str or pathlib.Path instance | Path to the mapped file. | offset : int | Offset position in the file. | mode : str | File mode. | | Methods | ------- | flush | Flush any changes in memory to file on disk. | When you delete a memmap object, flush is called first to write | changes to disk before removing the object. | | | See also | -------- | lib.format.open_memmap : Create or load a memory-mapped ``.npy`` file. | | Notes | ----- | The memmap object can be used anywhere an ndarray is accepted. | Given a memmap ``fp``, ``isinstance(fp, numpy.ndarray)`` returns | ``True``. | | Memory-mapped files cannot be larger than 2GB on 32-bit systems. | | When a memmap causes a file to be created or extended beyond its | current size in the filesystem, the contents of the new part are | unspecified. On systems with POSIX filesystem semantics, the extended | part will be filled with zero bytes. | | Examples | -------- | >>> data = np.arange(12, dtype='float32') | >>> data.resize((3,4)) | | This example uses a temporary file so that doctest doesn't write | files to your directory. You would use a 'normal' filename. | | >>> from tempfile import mkdtemp | >>> import os.path as path | >>> filename = path.join(mkdtemp(), 'newfile.dat') | | Create a memmap with dtype and shape that matches our data: | | >>> fp = np.memmap(filename, dtype='float32', mode='w+', shape=(3,4)) | >>> fp | memmap([[0., 0., 0., 0.], | [0., 0., 0., 0.], | [0., 0., 0., 0.]], dtype=float32) | | Write data to memmap array: | | >>> fp[:] = data[:] | >>> fp | memmap([[ 0., 1., 2., 3.], | [ 4., 5., 6., 7.], | [ 8., 9., 10., 11.]], dtype=float32) | | >>> fp.filename == path.abspath(filename) | True | | Deletion flushes memory changes to disk before removing the object: | | >>> del fp | | Load the memmap and verify data was stored: | | >>> newfp = np.memmap(filename, dtype='float32', mode='r', shape=(3,4)) | >>> newfp | memmap([[ 0., 1., 2., 3.], | [ 4., 5., 6., 7.], | [ 8., 9., 10., 11.]], dtype=float32) | | Read-only memmap: | | >>> fpr = np.memmap(filename, dtype='float32', mode='r', shape=(3,4)) | >>> fpr.flags.writeable | False | | Copy-on-write memmap: | | >>> fpc = np.memmap(filename, dtype='float32', mode='c', shape=(3,4)) | >>> fpc.flags.writeable | True | | It's possible to assign to copy-on-write array, but values are only | written into the memory copy of the array, and not written to disk: | | >>> fpc | memmap([[ 0., 1., 2., 3.], | [ 4., 5., 6., 7.], | [ 8., 9., 10., 11.]], dtype=float32) | >>> fpc[0,:] = 0 | >>> fpc | memmap([[ 0., 0., 0., 0.], | [ 4., 5., 6., 7.], | [ 8., 9., 10., 11.]], dtype=float32) | | File on disk is unchanged: | | >>> fpr | memmap([[ 0., 1., 2., 3.], | [ 4., 5., 6., 7.], | [ 8., 9., 10., 11.]], dtype=float32) | | Offset into a memmap: | | >>> fpo = np.memmap(filename, dtype='float32', mode='r', offset=16) | >>> fpo | memmap([ 4., 5., 6., 7., 8., 9., 10., 11.], dtype=float32) | | Method resolution order: | memmap | ndarray | builtins.object | | Methods defined here: | | __array_finalize__(self, obj) | None. | | __array_wrap__(self, arr, context=None) | a.__array_wrap__(obj) -> Object of same type as ndarray object a. | | __getitem__(self, index) | Return self[key]. | | flush(self) | Write any changes in the array to the file on disk. | | For further information, see `memmap`. | | Parameters | ---------- | None | | See Also | -------- | memmap | | ---------------------------------------------------------------------- | Static methods defined here: | | __new__(subtype, filename, dtype=<class 'numpy.uint8'>, mode='r+', offset=0, shape=None, order='C') | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Data descriptors defined here: | | __dict__ | dictionary for instance variables (if defined) | | ---------------------------------------------------------------------- | Data and other attributes defined here: | | __array_priority__ = -100.0 | | ---------------------------------------------------------------------- | Methods inherited from ndarray: | | __abs__(self, /) | abs(self) | | __add__(self, value, /) | Return self+value. | | __and__(self, value, /) | Return self&value. | | __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_function__(...) | | __array_prepare__(...) | a.__array_prepare__(obj) -> Object of same type as ndarray object obj. | | __array_ufunc__(...) | | __bool__(self, /) | self != 0 | | __complex__(...) | | __contains__(self, key, /) | Return key in self. | | __copy__(...) | a.__copy__() | | Used if :func:`copy.copy` is called on an array. Returns a copy of the array. | | Equivalent to ``a.copy(order='K')``. | | __deepcopy__(...) | a.__deepcopy__(memo, /) -> Deep copy of array. | | Used if :func:`copy.deepcopy` is called on an array. | | __delitem__(self, key, /) | Delete self[key]. | | __divmod__(self, value, /) | Return divmod(self, value). | | __eq__(self, value, /) | Return self==value. | | __float__(self, /) | float(self) | | __floordiv__(self, value, /) | Return self//value. | | __format__(...) | Default object formatter. | | __ge__(self, value, /) | Return self>=value. | | __gt__(self, value, /) | Return self>value. | | __iadd__(self, value, /) | Return self+=value. | | __iand__(self, value, /) | Return self&=value. | | __ifloordiv__(self, value, /) | Return self//=value. | | __ilshift__(self, value, /) | Return self<<=value. | | __imatmul__(self, value, /) | Return self@=value. | | __imod__(self, value, /) | Return self%=value. | | __imul__(self, value, /) | Return self*=value. | | __index__(self, /) | Return self converted to an integer, if self is suitable for use as an index into a list. | | __int__(self, /) | int(self) | | __invert__(self, /) | ~self | | __ior__(self, value, /) | Return self|=value. | | __ipow__(self, value, /) | Return self**=value. | | __irshift__(self, value, /) | Return self>>=value. | | __isub__(self, value, /) | Return self-=value. | | __iter__(self, /) | Implement iter(self). | | __itruediv__(self, value, /) | Return self/=value. | | __ixor__(self, value, /) | Return self^=value. | | __le__(self, value, /) | Return self<=value. | | __len__(self, /) | Return len(self). | | __lshift__(self, value, /) | Return self<<value. | | __lt__(self, value, /) | Return self<value. | | __matmul__(self, value, /) | Return self@value. | | __mod__(self, value, /) | Return self%value. | | __mul__(self, value, /) | Return self*value. | | __ne__(self, value, /) | Return self!=value. | | __neg__(self, /) | -self | | __or__(self, value, /) | Return self|value. | | __pos__(self, /) | +self | | __pow__(self, value, mod=None, /) | Return pow(self, value, mod). | | __radd__(self, value, /) | Return value+self. | | __rand__(self, value, /) | Return value&self. | | __rdivmod__(self, value, /) | Return divmod(value, self). | | __reduce__(...) | a.__reduce__() | | For pickling. | | __reduce_ex__(...) | Helper for pickle. | | __repr__(self, /) | Return repr(self). | | __rfloordiv__(self, value, /) | Return value//self. | | __rlshift__(self, value, /) | Return value<<self. | | __rmatmul__(self, value, /) | Return value@self. | | __rmod__(self, value, /) | Return value%self. | | __rmul__(self, value, /) | Return value*self. | | __ror__(self, value, /) | Return value|self. | | __rpow__(self, value, mod=None, /) | Return pow(value, self, mod). | | __rrshift__(self, value, /) | Return value>>self. | | __rshift__(self, value, /) | Return self>>value. | | __rsub__(self, value, /) | Return value-self. | | __rtruediv__(self, value, /) | Return value/self. | | __rxor__(self, value, /) | Return value^self. | | __setitem__(self, key, value, /) | Set self[key] to value. | | __setstate__(...) | a.__setstate__(state, /) | | For unpickling. | | The `state` argument must be a sequence that contains the following | elements: | | Parameters | ---------- | version : int | optional pickle version. If omitted defaults to 0. | shape : tuple | dtype : data-type | isFortran : bool | rawdata : string or list | a binary string with the data (or a list if 'a' is an object array) | | __sizeof__(...) | Size of object in memory, in bytes. | | __str__(self, /) | Return str(self). | | __sub__(self, value, /) | Return self-value. | | __truediv__(self, value, /) | Return self/value. | | __xor__(self, value, /) | Return self^value. | | all(...) | a.all(axis=None, out=None, keepdims=False) | | Returns True if all elements evaluate to True. | | Refer to `numpy.all` for full documentation. | | See Also | -------- | numpy.all : equivalent function | | any(...) | a.any(axis=None, out=None, keepdims=False) | | Returns True if any of the elements of `a` evaluate to True. | | Refer to `numpy.any` for full documentation. | | See Also | -------- | numpy.any : equivalent function | | argmax(...) | a.argmax(axis=None, out=None) | | Return indices of the maximum values along the given axis. | | Refer to `numpy.argmax` for full documentation. | | See Also | -------- | numpy.argmax : equivalent function | | argmin(...) | a.argmin(axis=None, out=None) | | Return indices of the minimum values along the given axis of `a`. | | Refer to `numpy.argmin` for detailed documentation. | | See Also | -------- | numpy.argmin : equivalent function | | argpartition(...) | a.argpartition(kth, axis=-1, kind='introselect', order=None) | | Returns the indices that would partition this array. | | Refer to `numpy.argpartition` for full documentation. | | .. versionadded:: 1.8.0 | | See Also | -------- | numpy.argpartition : equivalent function | | argsort(...) | a.argsort(axis=-1, kind=None, order=None) | | Returns the indices that would sort this array. | | Refer to `numpy.argsort` for full documentation. | | See Also | -------- | numpy.argsort : equivalent function | | astype(...) | a.astype(dtype, order='K', casting='unsafe', subok=True, copy=True) | | Copy of the array, cast to a specified type. | | Parameters | ---------- | dtype : str or dtype | Typecode or data-type to which the array is cast. | order : {'C', 'F', 'A', 'K'}, optional | Controls the memory layout order of the result. | 'C' means C order, 'F' means Fortran order, 'A' | means 'F' order if all the arrays are Fortran contiguous, | 'C' order otherwise, and 'K' means as close to the | order the array elements appear in memory as possible. | Default is 'K'. | casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional | Controls what kind of data casting may occur. Defaults to 'unsafe' | for backwards compatibility. | | * 'no' means the data types should not be cast at all. | * 'equiv' means only byte-order changes are allowed. | * 'safe' means only casts which can preserve values are allowed. | * 'same_kind' means only safe casts or casts within a kind, | like float64 to float32, are allowed. | * 'unsafe' means any data conversions may be done. | subok : bool, optional | If True, then sub-classes will be passed-through (default), otherwise | the returned array will be forced to be a base-class array. | copy : bool, optional | By default, astype always returns a newly allocated array. If this | is set to false, and the `dtype`, `order`, and `subok` | requirements are satisfied, the input array is returned instead | of a copy. | | Returns | ------- | arr_t : ndarray | Unless `copy` is False and the other conditions for returning the input | array are satisfied (see description for `copy` input parameter), `arr_t` | is a new array of the same shape as the input array, with dtype, order | given by `dtype`, `order`. | | Notes | ----- | .. versionchanged:: 1.17.0 | Casting between a simple data type and a structured one is possible only | for "unsafe" casting. Casting to multiple fields is allowed, but | casting from multiple fields is not. | | .. versionchanged:: 1.9.0 | Casting from numeric to string types in 'safe' casting mode requires | that the string dtype length is long enough to store the max | integer/float value converted. | | 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=False) | | 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. | Arrays of byte-strings are not swapped. The real and imaginary | parts of a complex number are swapped individually. | | 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) | >>> list(map(hex, A)) | ['0x1', '0x100', '0x2233'] | >>> A.byteswap(inplace=True) | array([ 256, 1, 13090], dtype=int16) | >>> list(map(hex, A)) | ['0x100', '0x1', '0x3322'] | | Arrays of byte-strings are not swapped | | >>> A = np.array([b'ceg', b'fac']) | >>> A.byteswap() | array([b'ceg', b'fac'], dtype='|S3') | | ``A.newbyteorder().byteswap()`` produces an array with the same values | but different representation in memory | | >>> A = np.array([1, 2, 3]) | >>> A.view(np.uint8) | array([1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, | 0, 0], dtype=uint8) | >>> A.newbyteorder().byteswap(inplace=True) | array([1, 2, 3]) | >>> A.view(np.uint8) | array([0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, | 0, 3], dtype=uint8) | | choose(...) | a.choose(choices, out=None, mode='raise') | | Use an index array to construct a new array from a set of choices. | | Refer to `numpy.choose` for full documentation. | | See Also | -------- | numpy.choose : equivalent function | | clip(...) | a.clip(min=None, max=None, out=None, **kwargs) | | Return an array whose values are limited to ``[min, max]``. | One of max or min must be given. | | Refer to `numpy.clip` for full documentation. | | See Also | -------- | numpy.clip : equivalent function | | compress(...) | a.compress(condition, axis=None, out=None) | | Return selected slices of this array along given axis. | | Refer to `numpy.compress` for full documentation. | | See Also | -------- | numpy.compress : equivalent function | | conj(...) | a.conj() | | Complex-conjugate all elements. | | Refer to `numpy.conjugate` for full documentation. | | See Also | -------- | numpy.conjugate : equivalent function | | conjugate(...) | a.conjugate() | | Return the complex conjugate, element-wise. | | Refer to `numpy.conjugate` for full documentation. | | See Also | -------- | numpy.conjugate : equivalent function | | copy(...) | a.copy(order='C') | | Return a copy of the array. | | Parameters | ---------- | order : {'C', 'F', 'A', 'K'}, optional | Controls the memory layout of the copy. 'C' means C-order, | 'F' means F-order, 'A' means 'F' if `a` is Fortran contiguous, | 'C' otherwise. 'K' means match the layout of `a` as closely | as possible. (Note that this function and :func:`numpy.copy` are very | similar, but have different default values for their order= | arguments.) | | See also | -------- | numpy.copy | numpy.copyto | | Examples | -------- | >>> x = np.array([[1,2,3],[4,5,6]], order='F') | | >>> y = x.copy() | | >>> x.fill(0) | | >>> x | array([[0, 0, 0], | [0, 0, 0]]) | | >>> y | array([[1, 2, 3], | [4, 5, 6]]) | | >>> y.flags['C_CONTIGUOUS'] | True | | cumprod(...) | a.cumprod(axis=None, dtype=None, out=None) | | Return the cumulative product of the elements along the given axis. | | Refer to `numpy.cumprod` for full documentation. | | See Also | -------- | numpy.cumprod : equivalent function | | cumsum(...) | a.cumsum(axis=None, dtype=None, out=None) | | Return the cumulative sum of the elements along the given axis. | | Refer to `numpy.cumsum` for full documentation. | | See Also | -------- | numpy.cumsum : equivalent function | | diagonal(...) | a.diagonal(offset=0, axis1=0, axis2=1) | | Return specified diagonals. In NumPy 1.9 the returned array is a | read-only view instead of a copy as in previous NumPy versions. In | a future version the read-only restriction will be removed. | | Refer to :func:`numpy.diagonal` for full documentation. | | See Also | -------- | numpy.diagonal : equivalent function | | dot(...) | a.dot(b, out=None) | | Dot product of two arrays. | | Refer to `numpy.dot` for full documentation. | | See Also | -------- | numpy.dot : equivalent function | | Examples | -------- | >>> a = np.eye(2) | >>> b = np.ones((2, 2)) * 2 | >>> a.dot(b) | array([[2., 2.], | [2., 2.]]) | | This array method can be conveniently chained: | | >>> a.dot(b).dot(b) | array([[8., 8.], | [8., 8.]]) | | dump(...) | a.dump(file) | | Dump a pickle of the array to the specified file. | The array can be read back with pickle.load or numpy.load. | | Parameters | ---------- | file : str or Path | A string naming the dump file. | | .. versionchanged:: 1.17.0 | `pathlib.Path` objects are now accepted. | | 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', 'K'}, optional | 'C' means to flatten in row-major (C-style) order. | 'F' means to flatten in column-major (Fortran- | style) order. 'A' means to flatten in column-major | order if `a` is Fortran *contiguous* in memory, | row-major order otherwise. 'K' means to flatten | `a` in the order the elements occur in memory. | The default is 'C'. | | Returns | ------- | y : ndarray | A copy of the input array, flattened to one dimension. | | See Also | -------- | ravel : Return a flattened array. | flat : A 1-D flat iterator over the array. | | Examples | -------- | >>> a = np.array([[1,2], [3,4]]) | >>> a.flatten() | array([1, 2, 3, 4]) | >>> a.flatten('F') | array([1, 3, 2, 4]) | | getfield(...) | a.getfield(dtype, offset=0) | | Returns a field of the given array as a certain type. | | A field is a view of the array data with a given data-type. The values in | the view are determined by the given type and the offset into the current | array in bytes. The offset needs to be such that the view dtype fits in the | array dtype; for example an array of dtype complex128 has 16-byte elements. | If taking a view with a 32-bit integer (4 bytes), the offset needs to be | between 0 and 12 bytes. | | Parameters | ---------- | dtype : str or dtype | The data type of the view. The dtype size of the view can not be larger | than that of the array itself. | offset : int | Number of bytes to skip before beginning the element view. | | Examples | -------- | >>> x = np.diag([1.+1.j]*2) | >>> x[1, 1] = 2 + 4.j | >>> x | array([[1.+1.j, 0.+0.j], | [0.+0.j, 2.+4.j]]) | >>> x.getfield(np.float64) | array([[1., 0.], | [0., 2.]]) | | By choosing an offset of 8 bytes we can select the complex part of the | array for our view: | | >>> x.getfield(np.float64, offset=8) | array([[1., 0.], | [0., 4.]]) | | item(...) | a.item(*args) | | Copy an element of an array to a standard Python scalar and return it. | | Parameters | ---------- | \*args : Arguments (variable number and type) | | * none: in this case, the method only works for arrays | with one element (`a.size == 1`), which element is | copied into a standard Python scalar object and returned. | | * int_type: this argument is interpreted as a flat index into | the array, specifying which element to copy and return. | | * tuple of int_types: functions as does a single int_type argument, | except that the argument is interpreted as an nd-index into the | array. | | Returns | ------- | z : Standard Python scalar object | A copy of the specified element of the array as a suitable | Python scalar | | Notes | ----- | When the data type of `a` is longdouble or clongdouble, item() returns | a scalar array object because there is no available Python scalar that | would not lose information. Void arrays return a buffer object for item(), | unless fields are defined, in which case a tuple is returned. | | `item` is very similar to a[args], except, instead of an array scalar, | a standard Python scalar is returned. This can be useful for speeding up | access to elements of the array and doing arithmetic on elements of the | array using Python's optimized math. | | Examples | -------- | >>> np.random.seed(123) | >>> x = np.random.randint(9, size=(3, 3)) | >>> x | array([[2, 2, 6], | [1, 3, 6], | [1, 0, 1]]) | >>> x.item(3) | 1 | >>> x.item(7) | 0 | >>> x.item((0, 1)) | 2 | >>> x.item((2, 2)) | 1 | | 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 | -------- | >>> np.random.seed(123) | >>> x = np.random.randint(9, size=(3, 3)) | >>> x | array([[2, 2, 6], | [1, 3, 6], | [1, 0, 1]]) | >>> x.itemset(4, 0) | >>> x.itemset((2, 2), 9) | >>> x | array([[2, 2, 6], | [1, 0, 6], | [1, 0, 9]]) | | max(...) | a.max(axis=None, out=None, keepdims=False, initial=<no value>, where=True) | | Return the maximum along a given axis. | | Refer to `numpy.amax` for full documentation. | | See Also | -------- | numpy.amax : equivalent function | | mean(...) | a.mean(axis=None, dtype=None, out=None, keepdims=False) | | Returns the average of the array elements along given axis. | | Refer to `numpy.mean` for full documentation. | | See Also | -------- | numpy.mean : equivalent function | | min(...) | a.min(axis=None, out=None, keepdims=False, initial=<no value>, where=True) | | Return the minimum along a given axis. | | Refer to `numpy.amin` for full documentation. | | See Also | -------- | numpy.amin : equivalent function | | newbyteorder(...) | arr.newbyteorder(new_order='S') | | Return the array with the same data viewed with a different byte order. | | Equivalent to:: | | arr.view(arr.dtype.newbytorder(new_order)) | | Changes are also made in all fields and sub-arrays of the array data | type. | | | | Parameters | ---------- | new_order : string, optional | Byte order to force; a value from the byte order specifications | below. `new_order` codes can be any of: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_arr : array | New array object with the dtype reflecting given change to the | byte order. | | nonzero(...) | a.nonzero() | | Return the indices of the elements that are non-zero. | | Refer to `numpy.nonzero` for full documentation. | | See Also | -------- | numpy.nonzero : equivalent function | | partition(...) | a.partition(kth, axis=-1, kind='introselect', order=None) | | Rearranges the elements in the array in such a way that the value of the | element in kth position is in the position it would be in a sorted array. | All elements smaller than the kth element are moved before this element and | all equal or greater are moved behind it. The ordering of the elements in | the two partitions is undefined. | | .. versionadded:: 1.8.0 | | Parameters | ---------- | kth : int or sequence of ints | Element index to partition by. The kth element value will be in its | final sorted position and all smaller elements will be moved before it | and all equal or greater elements behind it. | The order of all elements in the partitions is undefined. | If provided with a sequence of kth it will partition all elements | indexed by kth of them into their sorted position at once. | axis : int, optional | Axis along which to sort. Default is -1, which means sort along the | last axis. | kind : {'introselect'}, optional | Selection algorithm. Default is 'introselect'. | order : str or list of str, optional | When `a` is an array with fields defined, this argument specifies | which fields to compare first, second, etc. A single field can | be specified as a string, and not all fields need to be specified, | but unspecified fields will still be used, in the order in which | they come up in the dtype, to break ties. | | See Also | -------- | numpy.partition : Return a parititioned copy of an array. | argpartition : Indirect partition. | sort : Full sort. | | Notes | ----- | See ``np.partition`` for notes on the different algorithms. | | Examples | -------- | >>> a = np.array([3, 4, 2, 1]) | >>> a.partition(3) | >>> a | array([2, 1, 3, 4]) | | >>> a.partition((1, 3)) | >>> a | array([1, 2, 3, 4]) | | prod(...) | a.prod(axis=None, dtype=None, out=None, keepdims=False, initial=1, where=True) | | 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, keepdims=False) | | 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 | | Notes | ----- | Unlike the free function `numpy.reshape`, this method on `ndarray` allows | the elements of the shape parameter to be passed in as separate arguments. | For example, ``a.reshape(10, 11)`` is equivalent to | ``a.reshape((10, 11))``. | | 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. | PyPy only: will always raise if the data memory must be changed, since | there is no reliable way to determine if references or views to it | exist. | | 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 references or is 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]], dtype=int32) | >>> x | array([[1.0e+000, 1.5e-323, 1.5e-323], | [1.5e-323, 1.0e+000, 1.5e-323], | [1.5e-323, 1.5e-323, 1.0e+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, (WRITEBACKIFCOPY 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 WRITEBACKIFCOPY and (deprecated) UPDATEIFCOPY flags 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 7 Boolean flags | in use, only four of which can be changed by the user: | WRITEBACKIFCOPY, 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) (deprecated), replaced by WRITEBACKIFCOPY; | | WRITEBACKIFCOPY (X) this array is a copy of some other array (referenced | by .base). When the C-API function PyArray_ResolveWritebackIfCopy is | called, the base array will be updated with the contents of this array. | | All flags can be accessed using the single (upper case) letter as well | as the full name. | | Examples | -------- | >>> y = np.array([[3, 1, 7], | ... [2, 0, 0], | ... [8, 5, 9]]) | >>> 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 | WRITEBACKIFCOPY : False | UPDATEIFCOPY : False | >>> y.setflags(write=0, align=0) | >>> y.flags | C_CONTIGUOUS : True | F_CONTIGUOUS : False | OWNDATA : True | WRITEABLE : False | ALIGNED : False | WRITEBACKIFCOPY : False | UPDATEIFCOPY : False | >>> y.setflags(uic=1) | Traceback (most recent call last): | File "<stdin>", line 1, in <module> | ValueError: cannot set WRITEBACKIFCOPY flag to True | | sort(...) | a.sort(axis=-1, kind=None, order=None) | | Sort an array in-place. Refer to `numpy.sort` for full documentation. | | Parameters | ---------- | axis : int, optional | Axis along which to sort. Default is -1, which means sort along the | last axis. | kind : {'quicksort', 'mergesort', 'heapsort', 'stable'}, optional | Sorting algorithm. The default is 'quicksort'. Note that both 'stable' | and 'mergesort' use timsort under the covers and, in general, the | actual implementation will vary with datatype. The 'mergesort' option | is retained for backwards compatibility. | | .. versionchanged:: 1.15.0. | The 'stable' option was added. | | order : str or list of str, optional | When `a` is an array with fields defined, this argument specifies | which fields to compare first, second, etc. A single field can | be specified as a string, and not all fields need be specified, | but unspecified fields will still be used, in the order in which | they come up in the dtype, to break ties. | | See Also | -------- | numpy.sort : Return a sorted copy of an array. | numpy.argsort : Indirect sort. | numpy.lexsort : Indirect stable sort on multiple keys. | numpy.searchsorted : Find elements in sorted array. | numpy.partition: Partial sort. | | Notes | ----- | See `numpy.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([(b'c', 1), (b'a', 2)], | dtype=[('x', 'S1'), ('y', '<i8')]) | | squeeze(...) | a.squeeze(axis=None) | | Remove single-dimensional entries from the shape of `a`. | | Refer to `numpy.squeeze` for full documentation. | | See Also | -------- | numpy.squeeze : equivalent function | | std(...) | a.std(axis=None, dtype=None, out=None, ddof=0, keepdims=False) | | Returns the standard deviation of the array elements along given axis. | | Refer to `numpy.std` for full documentation. | | See Also | -------- | numpy.std : equivalent function | | sum(...) | a.sum(axis=None, dtype=None, out=None, keepdims=False, initial=0, where=True) | | Return the sum of the array elements over the given axis. | | Refer to `numpy.sum` for full documentation. | | See Also | -------- | numpy.sum : equivalent function | | swapaxes(...) | a.swapaxes(axis1, axis2) | | Return a view of the array with `axis1` and `axis2` interchanged. | | Refer to `numpy.swapaxes` for full documentation. | | See Also | -------- | numpy.swapaxes : equivalent function | | take(...) | a.take(indices, axis=None, out=None, mode='raise') | | Return an array formed from the elements of `a` at the given indices. | | Refer to `numpy.take` for full documentation. | | See Also | -------- | numpy.take : equivalent function | | tobytes(...) | a.tobytes(order='C') | | Construct Python bytes containing the raw data bytes in the array. | | Constructs Python bytes showing a copy of the raw contents of | data memory. The bytes object can be produced in either 'C' or 'Fortran', | or 'Any' order (the default is 'C'-order). 'Any' order means C-order | unless the F_CONTIGUOUS flag in the array is set, in which case it | means 'Fortran' order. | | .. versionadded:: 1.9.0 | | Parameters | ---------- | order : {'C', 'F', None}, optional | Order of the data for multidimensional arrays: | C, Fortran, or the same as for the original array. | | Returns | ------- | s : bytes | Python bytes exhibiting a copy of `a`'s raw data. | | Examples | -------- | >>> x = np.array([[0, 1], [2, 3]], dtype='<u2') | >>> x.tobytes() | b'\x00\x00\x01\x00\x02\x00\x03\x00' | >>> x.tobytes('C') == x.tobytes() | True | >>> x.tobytes('F') | b'\x00\x00\x02\x00\x01\x00\x03\x00' | | tofile(...) | a.tofile(fid, sep="", format="%s") | | Write array to a file as text or binary (default). | | Data is always written in 'C' order, independent of the order of `a`. | The data produced by this method can be recovered using the function | fromfile(). | | Parameters | ---------- | fid : file or str or Path | An open file object, or a string containing a filename. | | .. versionchanged:: 1.17.0 | `pathlib.Path` objects are now accepted. | | sep : str | Separator between array items for text output. | If "" (empty), a binary file is written, equivalent to | ``file.write(a.tobytes())``. | format : str | Format string for text file output. | Each entry in the array is formatted to text by first converting | it to the closest Python type, and then using "format" % item. | | Notes | ----- | This is a convenience function for quick storage of array data. | Information on endianness and precision is lost, so this method is not a | good choice for files intended to archive data or transport data between | machines with different endianness. Some of these problems can be overcome | by outputting the data as text files, at the expense of speed and file | size. | | When fid is a file object, array contents are directly written to the | file, bypassing the file object's ``write`` method. As a result, tofile | cannot be used with files objects supporting compression (e.g., GzipFile) | or file-like objects that do not support ``fileno()`` (e.g., BytesIO). | | tolist(...) | a.tolist() | | Return the array as an ``a.ndim``-levels deep nested list of Python scalars. | | Return a copy of the array data as a (nested) Python list. | Data items are converted to the nearest compatible builtin Python type, via | the `~numpy.ndarray.item` function. | | If ``a.ndim`` is 0, then since the depth of the nested list is 0, it will | not be a list at all, but a simple Python scalar. | | Parameters | ---------- | none | | Returns | ------- | y : object, or list of object, or list of list of object, or ... | The possibly nested list of array elements. | | Notes | ----- | The array may be recreated via ``a = np.array(a.tolist())``, although this | may sometimes lose precision. | | Examples | -------- | For a 1D array, ``a.tolist()`` is almost the same as ``list(a)``, | except that ``tolist`` changes numpy scalars to Python scalars: | | >>> a = np.uint32([1, 2]) | >>> a_list = list(a) | >>> a_list | [1, 2] | >>> type(a_list[0]) | <class 'numpy.uint32'> | >>> a_tolist = a.tolist() | >>> a_tolist | [1, 2] | >>> type(a_tolist[0]) | <class 'int'> | | Additionally, for a 2D array, ``tolist`` applies recursively: | | >>> a = np.array([[1, 2], [3, 4]]) | >>> list(a) | [array([1, 2]), array([3, 4])] | >>> a.tolist() | [[1, 2], [3, 4]] | | The base case for this recursion is a 0D array: | | >>> a = np.array(1) | >>> list(a) | Traceback (most recent call last): | ... | TypeError: iteration over a 0-d array | >>> a.tolist() | 1 | | tostring(...) | a.tostring(order='C') | | A compatibility alias for `tobytes`, with exactly the same behavior. | | Despite its name, it returns `bytes` not `str`\ s. | | .. deprecated:: 1.19.0 | | 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, as a transposed vector is simply the | same vector. To convert a 1-D array into a 2D column vector, an additional | dimension must be added. `np.atleast2d(a).T` achieves this, as does | `a[:, np.newaxis]`. | For a 2-D array, this is a standard 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. | ndarray.reshape : Give a new shape to an array without changing its data. | | Examples | -------- | >>> a = np.array([[1, 2], [3, 4]]) | >>> a | array([[1, 2], | [3, 4]]) | >>> a.transpose() | array([[1, 3], | [2, 4]]) | >>> a.transpose((1, 0)) | array([[1, 3], | [2, 4]]) | >>> a.transpose(1, 0) | array([[1, 3], | [2, 4]]) | | var(...) | a.var(axis=None, dtype=None, out=None, ddof=0, keepdims=False) | | Returns the variance of the array elements, along given axis. | | Refer to `numpy.var` for full documentation. | | See Also | -------- | numpy.var : equivalent function | | view(...) | a.view([dtype][, type]) | | New view of array with the same data. | | .. note:: | Passing None for ``dtype`` is different from omitting the parameter, | since the former invokes ``dtype(None)`` which is an alias for | ``dtype('float_')``. | | Parameters | ---------- | dtype : data-type or ndarray sub-class, optional | Data-type descriptor of the returned view, e.g., float32 or int16. | Omitting it 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, omission | of the parameter 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.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 | >>> x | array([(1, 20), (3, 4)], dtype=[('a', 'i1'), ('b', 'i1')]) | | Using a view to convert an array to a recarray: | | >>> z = x.view(np.recarray) | >>> z.a | array([1, 3], 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): | ... | ValueError: To change to a dtype of a different size, the array must be C-contiguous | >>> z = y.copy() | >>> z.view(dtype=[('width', np.int16), ('length', np.int16)]) | array([[(1, 2)], | [(4, 5)]], dtype=[('width', '<i2'), ('length', '<i2')]) | | ---------------------------------------------------------------------- | Data descriptors inherited from ndarray: | | T | The transposed array. | | Same as ``self.transpose()``. | | 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.]) | | See Also | -------- | transpose | | __array_interface__ | Array protocol: Python side. | | __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): | | .. autoattribute:: numpy.core._internal._ctypes.data | :noindex: | | .. autoattribute:: numpy.core._internal._ctypes.shape | :noindex: | | .. autoattribute:: numpy.core._internal._ctypes.strides | :noindex: | | .. automethod:: numpy.core._internal._ctypes.data_as | :noindex: | | .. automethod:: numpy.core._internal._ctypes.shape_as | :noindex: | | .. automethod:: numpy.core._internal._ctypes.strides_as | :noindex: | | 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 = np.array([[0, 1], [2, 3]], dtype=np.int32) | >>> x | array([[0, 1], | [2, 3]], dtype=int32) | >>> x.ctypes.data | 31962608 # may vary | >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_uint32)) | <__main__.LP_c_uint object at 0x7ff2fc1fc200> # may vary | >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_uint32)).contents | c_uint(0) | >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_uint64)).contents | c_ulong(4294967296) | >>> x.ctypes.shape | <numpy.core._internal.c_long_Array_2 object at 0x7ff2fc1fce60> # may vary | >>> x.ctypes.strides | <numpy.core._internal.c_long_Array_2 object at 0x7ff2fc1ff320> # may vary | | 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. | WRITEBACKIFCOPY (X) | This array is a copy of some other array. The C-API function | PyArray_ResolveWritebackIfCopy must be called before deallocating | to the base array will be updated with the contents of this array. | UPDATEIFCOPY (U) | (Deprecated, use WRITEBACKIFCOPY) 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 WRITEBACKIFCOPY, 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``. | - WRITEBACKIFCOPY 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) | <class '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. | | The shape property is usually used to get the current shape of an array, | but may also be used to reshape the array in-place by assigning a tuple of | array dimensions to it. As with `numpy.reshape`, one of the new shape | dimensions can be -1, in which case its value is inferred from the size of | the array and the remaining dimensions. Reshaping an array in-place will | fail if a copy is required. | | 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 | >>> np.zeros((4,2))[::2].shape = (-1,) | Traceback (most recent call last): | File "<stdin>", line 1, in <module> | AttributeError: Incompatible shape for in-place modification. Use | `.reshape()` to make a copy with the desired shape. | | See Also | -------- | numpy.reshape : similar function | ndarray.reshape : similar method | | size | Number of elements in the array. | | Equal to ``np.prod(a.shape)``, i.e., the product of the array's | dimensions. | | Notes | ----- | `a.size` returns a standard arbitrary precision Python integer. This | may not be the case with other methods of obtaining the same value | (like the suggested ``np.prod(a.shape)``, which returns an instance | of ``np.int_``), and may be relevant if the value is used further in | calculations that may overflow a fixed size integer type. | | Examples | -------- | >>> x = np.zeros((3, 5, 2), dtype=np.complex128) | >>> x.size | 30 | >>> np.prod(x.shape) | 30 | | strides | Tuple of bytes to step in each dimension when traversing an array. | | The byte offset of element ``(i[0], i[1], ..., i[n])`` in an array `a` | is:: | | offset = sum(np.array(i) * a.strides) | | A more detailed explanation of strides can be found in the | "ndarray.rst" file in the NumPy reference guide. | | Notes | ----- | Imagine an array of 32-bit integers (each 4 bytes):: | | x = np.array([[0, 1, 2, 3, 4], | [5, 6, 7, 8, 9]], dtype=np.int32) | | This array is stored in memory as 40 bytes, one after the other | (known as a contiguous block of memory). The strides of an array tell | us how many bytes we have to skip in memory to move to the next position | along a certain axis. For example, we have to skip 4 bytes (1 value) to | move to the next column, but 20 bytes (5 values) to get to the same | position in the next row. As such, the strides for the array `x` will be | ``(20, 4)``. | | See Also | -------- | numpy.lib.stride_tricks.as_strided | | Examples | -------- | >>> y = np.reshape(np.arange(2*3*4), (2,3,4)) | >>> y | array([[[ 0, 1, 2, 3], | [ 4, 5, 6, 7], | [ 8, 9, 10, 11]], | [[12, 13, 14, 15], | [16, 17, 18, 19], | [20, 21, 22, 23]]]) | >>> y.strides | (48, 16, 4) | >>> y[1,1,1] | 17 | >>> offset=sum(y.strides * np.array((1,1,1))) | >>> offset/y.itemsize | 17 | | >>> x = np.reshape(np.arange(5*6*7*8), (5,6,7,8)).transpose(2,3,1,0) | >>> x.strides | (32, 4, 224, 1344) | >>> i = np.array([3,5,2,2]) | >>> offset = sum(i * x.strides) | >>> x[3,5,2,2] | 813 | >>> offset / x.itemsize | 813 | | ---------------------------------------------------------------------- | Data and other attributes inherited from ndarray: | | __hash__ = None class ndarray(builtins.object) | ndarray(shape, dtype=float, buffer=None, offset=0, | strides=None, order=None) | | An array object represents a multidimensional, homogeneous array | of fixed-size items. An associated data-type object describes the | format of each element in the array (its byte-order, how many bytes it | occupies in memory, whether it is an integer, a floating point number, | or something else, etc.) | | Arrays should be constructed using `array`, `zeros` or `empty` (refer | to the See Also section below). The parameters given here refer to | a low-level method (`ndarray(...)`) for instantiating an array. | | For more information, refer to the `numpy` module and examine the | methods and attributes of an array. | | Parameters | ---------- | (for the __new__ method; see Notes below) | | shape : tuple of ints | Shape of created array. | dtype : data-type, optional | Any object that can be interpreted as a numpy data type. | buffer : object exposing buffer interface, optional | Used to fill the array with data. | offset : int, optional | Offset of array data in buffer. | strides : tuple of ints, optional | Strides of data in memory. | order : {'C', 'F'}, optional | Row-major (C-style) or column-major (Fortran-style) order. | | Attributes | ---------- | T : ndarray | Transpose of the array. | data : buffer | The array's elements, in memory. | dtype : dtype object | Describes the format of the elements in the array. | flags : dict | Dictionary containing information related to memory use, e.g., | 'C_CONTIGUOUS', 'OWNDATA', 'WRITEABLE', etc. | flat : numpy.flatiter object | Flattened version of the array as an iterator. The iterator | allows assignments, e.g., ``x.flat = 3`` (See `ndarray.flat` for | assignment examples; TODO). | imag : ndarray | Imaginary part of the array. | real : ndarray | Real part of the array. | size : int | Number of elements in the array. | itemsize : int | The memory use of each array element in bytes. | nbytes : int | The total number of bytes required to store the array data, | i.e., ``itemsize * size``. | ndim : int | The array's number of dimensions. | shape : tuple of ints | Shape of the array. | strides : tuple of ints | The step-size required to move from one element to the next in | memory. For example, a contiguous ``(3, 4)`` array of type | ``int16`` in C-order has strides ``(8, 2)``. This implies that | to move from element to element in memory requires jumps of 2 bytes. | To move from row-to-row, one needs to jump 8 bytes at a time | (``2 * 4``). | ctypes : ctypes object | Class containing properties of the array needed for interaction | with ctypes. | base : ndarray | If the array is a view into another array, that array is its `base` | (unless that array is also a view). The `base` array is where the | array data is actually stored. | | See Also | -------- | array : Construct an array. | zeros : Create an array, each element of which is zero. | empty : Create an array, but leave its allocated memory unchanged (i.e., | it contains "garbage"). | dtype : Create a data-type. | | Notes | ----- | There are two modes of creating an array using ``__new__``: | | 1. If `buffer` is None, then only `shape`, `dtype`, and `order` | are used. | 2. If `buffer` is an object exposing the buffer interface, then | all keywords are interpreted. | | No ``__init__`` method is needed because the array is fully initialized | after the ``__new__`` method. | | Examples | -------- | These examples illustrate the low-level `ndarray` constructor. Refer | to the `See Also` section above for easier ways of constructing an | ndarray. | | First mode, `buffer` is None: | | >>> np.ndarray(shape=(2,2), dtype=float, order='F') | array([[0.0e+000, 0.0e+000], # random | [ nan, 2.5e-323]]) | | Second mode: | | >>> np.ndarray((2,), buffer=np.array([1,2,3]), | ... offset=np.int_().itemsize, | ... dtype=int) # offset = 1*itemsize, i.e. skip first element | array([2, 3]) | | Methods defined here: | | __abs__(self, /) | abs(self) | | __add__(self, value, /) | Return self+value. | | __and__(self, value, /) | Return self&value. | | __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_function__(...) | | __array_prepare__(...) | a.__array_prepare__(obj) -> Object of same type as ndarray object obj. | | __array_ufunc__(...) | | __array_wrap__(...) | a.__array_wrap__(obj) -> Object of same type as ndarray object a. | | __bool__(self, /) | self != 0 | | __complex__(...) | | __contains__(self, key, /) | Return key in self. | | __copy__(...) | a.__copy__() | | Used if :func:`copy.copy` is called on an array. Returns a copy of the array. | | Equivalent to ``a.copy(order='K')``. | | __deepcopy__(...) | a.__deepcopy__(memo, /) -> Deep copy of array. | | Used if :func:`copy.deepcopy` is called on an array. | | __delitem__(self, key, /) | Delete self[key]. | | __divmod__(self, value, /) | Return divmod(self, value). | | __eq__(self, value, /) | Return self==value. | | __float__(self, /) | float(self) | | __floordiv__(self, value, /) | Return self//value. | | __format__(...) | Default object formatter. | | __ge__(self, value, /) | Return self>=value. | | __getitem__(self, key, /) | Return self[key]. | | __gt__(self, value, /) | Return self>value. | | __iadd__(self, value, /) | Return self+=value. | | __iand__(self, value, /) | Return self&=value. | | __ifloordiv__(self, value, /) | Return self//=value. | | __ilshift__(self, value, /) | Return self<<=value. | | __imatmul__(self, value, /) | Return self@=value. | | __imod__(self, value, /) | Return self%=value. | | __imul__(self, value, /) | Return self*=value. | | __index__(self, /) | Return self converted to an integer, if self is suitable for use as an index into a list. | | __int__(self, /) | int(self) | | __invert__(self, /) | ~self | | __ior__(self, value, /) | Return self|=value. | | __ipow__(self, value, /) | Return self**=value. | | __irshift__(self, value, /) | Return self>>=value. | | __isub__(self, value, /) | Return self-=value. | | __iter__(self, /) | Implement iter(self). | | __itruediv__(self, value, /) | Return self/=value. | | __ixor__(self, value, /) | Return self^=value. | | __le__(self, value, /) | Return self<=value. | | __len__(self, /) | Return len(self). | | __lshift__(self, value, /) | Return self<<value. | | __lt__(self, value, /) | Return self<value. | | __matmul__(self, value, /) | Return self@value. | | __mod__(self, value, /) | Return self%value. | | __mul__(self, value, /) | Return self*value. | | __ne__(self, value, /) | Return self!=value. | | __neg__(self, /) | -self | | __or__(self, value, /) | Return self|value. | | __pos__(self, /) | +self | | __pow__(self, value, mod=None, /) | Return pow(self, value, mod). | | __radd__(self, value, /) | Return value+self. | | __rand__(self, value, /) | Return value&self. | | __rdivmod__(self, value, /) | Return divmod(value, self). | | __reduce__(...) | a.__reduce__() | | For pickling. | | __reduce_ex__(...) | Helper for pickle. | | __repr__(self, /) | Return repr(self). | | __rfloordiv__(self, value, /) | Return value//self. | | __rlshift__(self, value, /) | Return value<<self. | | __rmatmul__(self, value, /) | Return value@self. | | __rmod__(self, value, /) | Return value%self. | | __rmul__(self, value, /) | Return value*self. | | __ror__(self, value, /) | Return value|self. | | __rpow__(self, value, mod=None, /) | Return pow(value, self, mod). | | __rrshift__(self, value, /) | Return value>>self. | | __rshift__(self, value, /) | Return self>>value. | | __rsub__(self, value, /) | Return value-self. | | __rtruediv__(self, value, /) | Return value/self. | | __rxor__(self, value, /) | Return value^self. | | __setitem__(self, key, value, /) | Set self[key] to value. | | __setstate__(...) | a.__setstate__(state, /) | | For unpickling. | | The `state` argument must be a sequence that contains the following | elements: | | Parameters | ---------- | version : int | optional pickle version. If omitted defaults to 0. | shape : tuple | dtype : data-type | isFortran : bool | rawdata : string or list | a binary string with the data (or a list if 'a' is an object array) | | __sizeof__(...) | Size of object in memory, in bytes. | | __str__(self, /) | Return str(self). | | __sub__(self, value, /) | Return self-value. | | __truediv__(self, value, /) | Return self/value. | | __xor__(self, value, /) | Return self^value. | | all(...) | a.all(axis=None, out=None, keepdims=False) | | Returns True if all elements evaluate to True. | | Refer to `numpy.all` for full documentation. | | See Also | -------- | numpy.all : equivalent function | | any(...) | a.any(axis=None, out=None, keepdims=False) | | Returns True if any of the elements of `a` evaluate to True. | | Refer to `numpy.any` for full documentation. | | See Also | -------- | numpy.any : equivalent function | | argmax(...) | a.argmax(axis=None, out=None) | | Return indices of the maximum values along the given axis. | | Refer to `numpy.argmax` for full documentation. | | See Also | -------- | numpy.argmax : equivalent function | | argmin(...) | a.argmin(axis=None, out=None) | | Return indices of the minimum values along the given axis of `a`. | | Refer to `numpy.argmin` for detailed documentation. | | See Also | -------- | numpy.argmin : equivalent function | | argpartition(...) | a.argpartition(kth, axis=-1, kind='introselect', order=None) | | Returns the indices that would partition this array. | | Refer to `numpy.argpartition` for full documentation. | | .. versionadded:: 1.8.0 | | See Also | -------- | numpy.argpartition : equivalent function | | argsort(...) | a.argsort(axis=-1, kind=None, order=None) | | Returns the indices that would sort this array. | | Refer to `numpy.argsort` for full documentation. | | See Also | -------- | numpy.argsort : equivalent function | | astype(...) | a.astype(dtype, order='K', casting='unsafe', subok=True, copy=True) | | Copy of the array, cast to a specified type. | | Parameters | ---------- | dtype : str or dtype | Typecode or data-type to which the array is cast. | order : {'C', 'F', 'A', 'K'}, optional | Controls the memory layout order of the result. | 'C' means C order, 'F' means Fortran order, 'A' | means 'F' order if all the arrays are Fortran contiguous, | 'C' order otherwise, and 'K' means as close to the | order the array elements appear in memory as possible. | Default is 'K'. | casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional | Controls what kind of data casting may occur. Defaults to 'unsafe' | for backwards compatibility. | | * 'no' means the data types should not be cast at all. | * 'equiv' means only byte-order changes are allowed. | * 'safe' means only casts which can preserve values are allowed. | * 'same_kind' means only safe casts or casts within a kind, | like float64 to float32, are allowed. | * 'unsafe' means any data conversions may be done. | subok : bool, optional | If True, then sub-classes will be passed-through (default), otherwise | the returned array will be forced to be a base-class array. | copy : bool, optional | By default, astype always returns a newly allocated array. If this | is set to false, and the `dtype`, `order`, and `subok` | requirements are satisfied, the input array is returned instead | of a copy. | | Returns | ------- | arr_t : ndarray | Unless `copy` is False and the other conditions for returning the input | array are satisfied (see description for `copy` input parameter), `arr_t` | is a new array of the same shape as the input array, with dtype, order | given by `dtype`, `order`. | | Notes | ----- | .. versionchanged:: 1.17.0 | Casting between a simple data type and a structured one is possible only | for "unsafe" casting. Casting to multiple fields is allowed, but | casting from multiple fields is not. | | .. versionchanged:: 1.9.0 | Casting from numeric to string types in 'safe' casting mode requires | that the string dtype length is long enough to store the max | integer/float value converted. | | 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=False) | | 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. | Arrays of byte-strings are not swapped. The real and imaginary | parts of a complex number are swapped individually. | | 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) | >>> list(map(hex, A)) | ['0x1', '0x100', '0x2233'] | >>> A.byteswap(inplace=True) | array([ 256, 1, 13090], dtype=int16) | >>> list(map(hex, A)) | ['0x100', '0x1', '0x3322'] | | Arrays of byte-strings are not swapped | | >>> A = np.array([b'ceg', b'fac']) | >>> A.byteswap() | array([b'ceg', b'fac'], dtype='|S3') | | ``A.newbyteorder().byteswap()`` produces an array with the same values | but different representation in memory | | >>> A = np.array([1, 2, 3]) | >>> A.view(np.uint8) | array([1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, | 0, 0], dtype=uint8) | >>> A.newbyteorder().byteswap(inplace=True) | array([1, 2, 3]) | >>> A.view(np.uint8) | array([0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, | 0, 3], dtype=uint8) | | choose(...) | a.choose(choices, out=None, mode='raise') | | Use an index array to construct a new array from a set of choices. | | Refer to `numpy.choose` for full documentation. | | See Also | -------- | numpy.choose : equivalent function | | clip(...) | a.clip(min=None, max=None, out=None, **kwargs) | | Return an array whose values are limited to ``[min, max]``. | One of max or min must be given. | | Refer to `numpy.clip` for full documentation. | | See Also | -------- | numpy.clip : equivalent function | | compress(...) | a.compress(condition, axis=None, out=None) | | Return selected slices of this array along given axis. | | Refer to `numpy.compress` for full documentation. | | See Also | -------- | numpy.compress : equivalent function | | conj(...) | a.conj() | | Complex-conjugate all elements. | | Refer to `numpy.conjugate` for full documentation. | | See Also | -------- | numpy.conjugate : equivalent function | | conjugate(...) | a.conjugate() | | Return the complex conjugate, element-wise. | | Refer to `numpy.conjugate` for full documentation. | | See Also | -------- | numpy.conjugate : equivalent function | | copy(...) | a.copy(order='C') | | Return a copy of the array. | | Parameters | ---------- | order : {'C', 'F', 'A', 'K'}, optional | Controls the memory layout of the copy. 'C' means C-order, | 'F' means F-order, 'A' means 'F' if `a` is Fortran contiguous, | 'C' otherwise. 'K' means match the layout of `a` as closely | as possible. (Note that this function and :func:`numpy.copy` are very | similar, but have different default values for their order= | arguments.) | | See also | -------- | numpy.copy | numpy.copyto | | Examples | -------- | >>> x = np.array([[1,2,3],[4,5,6]], order='F') | | >>> y = x.copy() | | >>> x.fill(0) | | >>> x | array([[0, 0, 0], | [0, 0, 0]]) | | >>> y | array([[1, 2, 3], | [4, 5, 6]]) | | >>> y.flags['C_CONTIGUOUS'] | True | | cumprod(...) | a.cumprod(axis=None, dtype=None, out=None) | | Return the cumulative product of the elements along the given axis. | | Refer to `numpy.cumprod` for full documentation. | | See Also | -------- | numpy.cumprod : equivalent function | | cumsum(...) | a.cumsum(axis=None, dtype=None, out=None) | | Return the cumulative sum of the elements along the given axis. | | Refer to `numpy.cumsum` for full documentation. | | See Also | -------- | numpy.cumsum : equivalent function | | diagonal(...) | a.diagonal(offset=0, axis1=0, axis2=1) | | Return specified diagonals. In NumPy 1.9 the returned array is a | read-only view instead of a copy as in previous NumPy versions. In | a future version the read-only restriction will be removed. | | Refer to :func:`numpy.diagonal` for full documentation. | | See Also | -------- | numpy.diagonal : equivalent function | | dot(...) | a.dot(b, out=None) | | Dot product of two arrays. | | Refer to `numpy.dot` for full documentation. | | See Also | -------- | numpy.dot : equivalent function | | Examples | -------- | >>> a = np.eye(2) | >>> b = np.ones((2, 2)) * 2 | >>> a.dot(b) | array([[2., 2.], | [2., 2.]]) | | This array method can be conveniently chained: | | >>> a.dot(b).dot(b) | array([[8., 8.], | [8., 8.]]) | | dump(...) | a.dump(file) | | Dump a pickle of the array to the specified file. | The array can be read back with pickle.load or numpy.load. | | Parameters | ---------- | file : str or Path | A string naming the dump file. | | .. versionchanged:: 1.17.0 | `pathlib.Path` objects are now accepted. | | 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', 'K'}, optional | 'C' means to flatten in row-major (C-style) order. | 'F' means to flatten in column-major (Fortran- | style) order. 'A' means to flatten in column-major | order if `a` is Fortran *contiguous* in memory, | row-major order otherwise. 'K' means to flatten | `a` in the order the elements occur in memory. | The default is 'C'. | | Returns | ------- | y : ndarray | A copy of the input array, flattened to one dimension. | | See Also | -------- | ravel : Return a flattened array. | flat : A 1-D flat iterator over the array. | | Examples | -------- | >>> a = np.array([[1,2], [3,4]]) | >>> a.flatten() | array([1, 2, 3, 4]) | >>> a.flatten('F') | array([1, 3, 2, 4]) | | getfield(...) | a.getfield(dtype, offset=0) | | Returns a field of the given array as a certain type. | | A field is a view of the array data with a given data-type. The values in | the view are determined by the given type and the offset into the current | array in bytes. The offset needs to be such that the view dtype fits in the | array dtype; for example an array of dtype complex128 has 16-byte elements. | If taking a view with a 32-bit integer (4 bytes), the offset needs to be | between 0 and 12 bytes. | | Parameters | ---------- | dtype : str or dtype | The data type of the view. The dtype size of the view can not be larger | than that of the array itself. | offset : int | Number of bytes to skip before beginning the element view. | | Examples | -------- | >>> x = np.diag([1.+1.j]*2) | >>> x[1, 1] = 2 + 4.j | >>> x | array([[1.+1.j, 0.+0.j], | [0.+0.j, 2.+4.j]]) | >>> x.getfield(np.float64) | array([[1., 0.], | [0., 2.]]) | | By choosing an offset of 8 bytes we can select the complex part of the | array for our view: | | >>> x.getfield(np.float64, offset=8) | array([[1., 0.], | [0., 4.]]) | | item(...) | a.item(*args) | | Copy an element of an array to a standard Python scalar and return it. | | Parameters | ---------- | \*args : Arguments (variable number and type) | | * none: in this case, the method only works for arrays | with one element (`a.size == 1`), which element is | copied into a standard Python scalar object and returned. | | * int_type: this argument is interpreted as a flat index into | the array, specifying which element to copy and return. | | * tuple of int_types: functions as does a single int_type argument, | except that the argument is interpreted as an nd-index into the | array. | | Returns | ------- | z : Standard Python scalar object | A copy of the specified element of the array as a suitable | Python scalar | | Notes | ----- | When the data type of `a` is longdouble or clongdouble, item() returns | a scalar array object because there is no available Python scalar that | would not lose information. Void arrays return a buffer object for item(), | unless fields are defined, in which case a tuple is returned. | | `item` is very similar to a[args], except, instead of an array scalar, | a standard Python scalar is returned. This can be useful for speeding up | access to elements of the array and doing arithmetic on elements of the | array using Python's optimized math. | | Examples | -------- | >>> np.random.seed(123) | >>> x = np.random.randint(9, size=(3, 3)) | >>> x | array([[2, 2, 6], | [1, 3, 6], | [1, 0, 1]]) | >>> x.item(3) | 1 | >>> x.item(7) | 0 | >>> x.item((0, 1)) | 2 | >>> x.item((2, 2)) | 1 | | 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 | -------- | >>> np.random.seed(123) | >>> x = np.random.randint(9, size=(3, 3)) | >>> x | array([[2, 2, 6], | [1, 3, 6], | [1, 0, 1]]) | >>> x.itemset(4, 0) | >>> x.itemset((2, 2), 9) | >>> x | array([[2, 2, 6], | [1, 0, 6], | [1, 0, 9]]) | | max(...) | a.max(axis=None, out=None, keepdims=False, initial=<no value>, where=True) | | Return the maximum along a given axis. | | Refer to `numpy.amax` for full documentation. | | See Also | -------- | numpy.amax : equivalent function | | mean(...) | a.mean(axis=None, dtype=None, out=None, keepdims=False) | | Returns the average of the array elements along given axis. | | Refer to `numpy.mean` for full documentation. | | See Also | -------- | numpy.mean : equivalent function | | min(...) | a.min(axis=None, out=None, keepdims=False, initial=<no value>, where=True) | | Return the minimum along a given axis. | | Refer to `numpy.amin` for full documentation. | | See Also | -------- | numpy.amin : equivalent function | | newbyteorder(...) | arr.newbyteorder(new_order='S') | | Return the array with the same data viewed with a different byte order. | | Equivalent to:: | | arr.view(arr.dtype.newbytorder(new_order)) | | Changes are also made in all fields and sub-arrays of the array data | type. | | | | Parameters | ---------- | new_order : string, optional | Byte order to force; a value from the byte order specifications | below. `new_order` codes can be any of: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_arr : array | New array object with the dtype reflecting given change to the | byte order. | | nonzero(...) | a.nonzero() | | Return the indices of the elements that are non-zero. | | Refer to `numpy.nonzero` for full documentation. | | See Also | -------- | numpy.nonzero : equivalent function | | partition(...) | a.partition(kth, axis=-1, kind='introselect', order=None) | | Rearranges the elements in the array in such a way that the value of the | element in kth position is in the position it would be in a sorted array. | All elements smaller than the kth element are moved before this element and | all equal or greater are moved behind it. The ordering of the elements in | the two partitions is undefined. | | .. versionadded:: 1.8.0 | | Parameters | ---------- | kth : int or sequence of ints | Element index to partition by. The kth element value will be in its | final sorted position and all smaller elements will be moved before it | and all equal or greater elements behind it. | The order of all elements in the partitions is undefined. | If provided with a sequence of kth it will partition all elements | indexed by kth of them into their sorted position at once. | axis : int, optional | Axis along which to sort. Default is -1, which means sort along the | last axis. | kind : {'introselect'}, optional | Selection algorithm. Default is 'introselect'. | order : str or list of str, optional | When `a` is an array with fields defined, this argument specifies | which fields to compare first, second, etc. A single field can | be specified as a string, and not all fields need to be specified, | but unspecified fields will still be used, in the order in which | they come up in the dtype, to break ties. | | See Also | -------- | numpy.partition : Return a parititioned copy of an array. | argpartition : Indirect partition. | sort : Full sort. | | Notes | ----- | See ``np.partition`` for notes on the different algorithms. | | Examples | -------- | >>> a = np.array([3, 4, 2, 1]) | >>> a.partition(3) | >>> a | array([2, 1, 3, 4]) | | >>> a.partition((1, 3)) | >>> a | array([1, 2, 3, 4]) | | prod(...) | a.prod(axis=None, dtype=None, out=None, keepdims=False, initial=1, where=True) | | 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, keepdims=False) | | 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 | | Notes | ----- | Unlike the free function `numpy.reshape`, this method on `ndarray` allows | the elements of the shape parameter to be passed in as separate arguments. | For example, ``a.reshape(10, 11)`` is equivalent to | ``a.reshape((10, 11))``. | | 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. | PyPy only: will always raise if the data memory must be changed, since | there is no reliable way to determine if references or views to it | exist. | | 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 references or is 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]], dtype=int32) | >>> x | array([[1.0e+000, 1.5e-323, 1.5e-323], | [1.5e-323, 1.0e+000, 1.5e-323], | [1.5e-323, 1.5e-323, 1.0e+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, (WRITEBACKIFCOPY 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 WRITEBACKIFCOPY and (deprecated) UPDATEIFCOPY flags 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 7 Boolean flags | in use, only four of which can be changed by the user: | WRITEBACKIFCOPY, 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) (deprecated), replaced by WRITEBACKIFCOPY; | | WRITEBACKIFCOPY (X) this array is a copy of some other array (referenced | by .base). When the C-API function PyArray_ResolveWritebackIfCopy is | called, the base array will be updated with the contents of this array. | | All flags can be accessed using the single (upper case) letter as well | as the full name. | | Examples | -------- | >>> y = np.array([[3, 1, 7], | ... [2, 0, 0], | ... [8, 5, 9]]) | >>> 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 | WRITEBACKIFCOPY : False | UPDATEIFCOPY : False | >>> y.setflags(write=0, align=0) | >>> y.flags | C_CONTIGUOUS : True | F_CONTIGUOUS : False | OWNDATA : True | WRITEABLE : False | ALIGNED : False | WRITEBACKIFCOPY : False | UPDATEIFCOPY : False | >>> y.setflags(uic=1) | Traceback (most recent call last): | File "<stdin>", line 1, in <module> | ValueError: cannot set WRITEBACKIFCOPY flag to True | | sort(...) | a.sort(axis=-1, kind=None, order=None) | | Sort an array in-place. Refer to `numpy.sort` for full documentation. | | Parameters | ---------- | axis : int, optional | Axis along which to sort. Default is -1, which means sort along the | last axis. | kind : {'quicksort', 'mergesort', 'heapsort', 'stable'}, optional | Sorting algorithm. The default is 'quicksort'. Note that both 'stable' | and 'mergesort' use timsort under the covers and, in general, the | actual implementation will vary with datatype. The 'mergesort' option | is retained for backwards compatibility. | | .. versionchanged:: 1.15.0. | The 'stable' option was added. | | order : str or list of str, optional | When `a` is an array with fields defined, this argument specifies | which fields to compare first, second, etc. A single field can | be specified as a string, and not all fields need be specified, | but unspecified fields will still be used, in the order in which | they come up in the dtype, to break ties. | | See Also | -------- | numpy.sort : Return a sorted copy of an array. | numpy.argsort : Indirect sort. | numpy.lexsort : Indirect stable sort on multiple keys. | numpy.searchsorted : Find elements in sorted array. | numpy.partition: Partial sort. | | Notes | ----- | See `numpy.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([(b'c', 1), (b'a', 2)], | dtype=[('x', 'S1'), ('y', '<i8')]) | | squeeze(...) | a.squeeze(axis=None) | | Remove single-dimensional entries from the shape of `a`. | | Refer to `numpy.squeeze` for full documentation. | | See Also | -------- | numpy.squeeze : equivalent function | | std(...) | a.std(axis=None, dtype=None, out=None, ddof=0, keepdims=False) | | Returns the standard deviation of the array elements along given axis. | | Refer to `numpy.std` for full documentation. | | See Also | -------- | numpy.std : equivalent function | | sum(...) | a.sum(axis=None, dtype=None, out=None, keepdims=False, initial=0, where=True) | | Return the sum of the array elements over the given axis. | | Refer to `numpy.sum` for full documentation. | | See Also | -------- | numpy.sum : equivalent function | | swapaxes(...) | a.swapaxes(axis1, axis2) | | Return a view of the array with `axis1` and `axis2` interchanged. | | Refer to `numpy.swapaxes` for full documentation. | | See Also | -------- | numpy.swapaxes : equivalent function | | take(...) | a.take(indices, axis=None, out=None, mode='raise') | | Return an array formed from the elements of `a` at the given indices. | | Refer to `numpy.take` for full documentation. | | See Also | -------- | numpy.take : equivalent function | | tobytes(...) | a.tobytes(order='C') | | Construct Python bytes containing the raw data bytes in the array. | | Constructs Python bytes showing a copy of the raw contents of | data memory. The bytes object can be produced in either 'C' or 'Fortran', | or 'Any' order (the default is 'C'-order). 'Any' order means C-order | unless the F_CONTIGUOUS flag in the array is set, in which case it | means 'Fortran' order. | | .. versionadded:: 1.9.0 | | Parameters | ---------- | order : {'C', 'F', None}, optional | Order of the data for multidimensional arrays: | C, Fortran, or the same as for the original array. | | Returns | ------- | s : bytes | Python bytes exhibiting a copy of `a`'s raw data. | | Examples | -------- | >>> x = np.array([[0, 1], [2, 3]], dtype='<u2') | >>> x.tobytes() | b'\x00\x00\x01\x00\x02\x00\x03\x00' | >>> x.tobytes('C') == x.tobytes() | True | >>> x.tobytes('F') | b'\x00\x00\x02\x00\x01\x00\x03\x00' | | tofile(...) | a.tofile(fid, sep="", format="%s") | | Write array to a file as text or binary (default). | | Data is always written in 'C' order, independent of the order of `a`. | The data produced by this method can be recovered using the function | fromfile(). | | Parameters | ---------- | fid : file or str or Path | An open file object, or a string containing a filename. | | .. versionchanged:: 1.17.0 | `pathlib.Path` objects are now accepted. | | sep : str | Separator between array items for text output. | If "" (empty), a binary file is written, equivalent to | ``file.write(a.tobytes())``. | format : str | Format string for text file output. | Each entry in the array is formatted to text by first converting | it to the closest Python type, and then using "format" % item. | | Notes | ----- | This is a convenience function for quick storage of array data. | Information on endianness and precision is lost, so this method is not a | good choice for files intended to archive data or transport data between | machines with different endianness. Some of these problems can be overcome | by outputting the data as text files, at the expense of speed and file | size. | | When fid is a file object, array contents are directly written to the | file, bypassing the file object's ``write`` method. As a result, tofile | cannot be used with files objects supporting compression (e.g., GzipFile) | or file-like objects that do not support ``fileno()`` (e.g., BytesIO). | | tolist(...) | a.tolist() | | Return the array as an ``a.ndim``-levels deep nested list of Python scalars. | | Return a copy of the array data as a (nested) Python list. | Data items are converted to the nearest compatible builtin Python type, via | the `~numpy.ndarray.item` function. | | If ``a.ndim`` is 0, then since the depth of the nested list is 0, it will | not be a list at all, but a simple Python scalar. | | Parameters | ---------- | none | | Returns | ------- | y : object, or list of object, or list of list of object, or ... | The possibly nested list of array elements. | | Notes | ----- | The array may be recreated via ``a = np.array(a.tolist())``, although this | may sometimes lose precision. | | Examples | -------- | For a 1D array, ``a.tolist()`` is almost the same as ``list(a)``, | except that ``tolist`` changes numpy scalars to Python scalars: | | >>> a = np.uint32([1, 2]) | >>> a_list = list(a) | >>> a_list | [1, 2] | >>> type(a_list[0]) | <class 'numpy.uint32'> | >>> a_tolist = a.tolist() | >>> a_tolist | [1, 2] | >>> type(a_tolist[0]) | <class 'int'> | | Additionally, for a 2D array, ``tolist`` applies recursively: | | >>> a = np.array([[1, 2], [3, 4]]) | >>> list(a) | [array([1, 2]), array([3, 4])] | >>> a.tolist() | [[1, 2], [3, 4]] | | The base case for this recursion is a 0D array: | | >>> a = np.array(1) | >>> list(a) | Traceback (most recent call last): | ... | TypeError: iteration over a 0-d array | >>> a.tolist() | 1 | | tostring(...) | a.tostring(order='C') | | A compatibility alias for `tobytes`, with exactly the same behavior. | | Despite its name, it returns `bytes` not `str`\ s. | | .. deprecated:: 1.19.0 | | 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, as a transposed vector is simply the | same vector. To convert a 1-D array into a 2D column vector, an additional | dimension must be added. `np.atleast2d(a).T` achieves this, as does | `a[:, np.newaxis]`. | For a 2-D array, this is a standard 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. | ndarray.reshape : Give a new shape to an array without changing its data. | | Examples | -------- | >>> a = np.array([[1, 2], [3, 4]]) | >>> a | array([[1, 2], | [3, 4]]) | >>> a.transpose() | array([[1, 3], | [2, 4]]) | >>> a.transpose((1, 0)) | array([[1, 3], | [2, 4]]) | >>> a.transpose(1, 0) | array([[1, 3], | [2, 4]]) | | var(...) | a.var(axis=None, dtype=None, out=None, ddof=0, keepdims=False) | | Returns the variance of the array elements, along given axis. | | Refer to `numpy.var` for full documentation. | | See Also | -------- | numpy.var : equivalent function | | view(...) | a.view([dtype][, type]) | | New view of array with the same data. | | .. note:: | Passing None for ``dtype`` is different from omitting the parameter, | since the former invokes ``dtype(None)`` which is an alias for | ``dtype('float_')``. | | Parameters | ---------- | dtype : data-type or ndarray sub-class, optional | Data-type descriptor of the returned view, e.g., float32 or int16. | Omitting it 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, omission | of the parameter 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.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 | >>> x | array([(1, 20), (3, 4)], dtype=[('a', 'i1'), ('b', 'i1')]) | | Using a view to convert an array to a recarray: | | >>> z = x.view(np.recarray) | >>> z.a | array([1, 3], 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): | ... | ValueError: To change to a dtype of a different size, the array must be C-contiguous | >>> z = y.copy() | >>> z.view(dtype=[('width', np.int16), ('length', np.int16)]) | array([[(1, 2)], | [(4, 5)]], dtype=[('width', '<i2'), ('length', '<i2')]) | | ---------------------------------------------------------------------- | Static methods defined here: | | __new__(*args, **kwargs) from builtins.type | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Data descriptors defined here: | | T | The transposed array. | | Same as ``self.transpose()``. | | 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.]) | | See Also | -------- | transpose | | __array_finalize__ | None. | | __array_interface__ | Array protocol: Python side. | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: C-struct side. | | base | Base object if memory is from some other object. | | Examples | -------- | 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): | | .. autoattribute:: numpy.core._internal._ctypes.data | :noindex: | | .. autoattribute:: numpy.core._internal._ctypes.shape | :noindex: | | .. autoattribute:: numpy.core._internal._ctypes.strides | :noindex: | | .. automethod:: numpy.core._internal._ctypes.data_as | :noindex: | | .. automethod:: numpy.core._internal._ctypes.shape_as | :noindex: | | .. automethod:: numpy.core._internal._ctypes.strides_as | :noindex: | | 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 = np.array([[0, 1], [2, 3]], dtype=np.int32) | >>> x | array([[0, 1], | [2, 3]], dtype=int32) | >>> x.ctypes.data | 31962608 # may vary | >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_uint32)) | <__main__.LP_c_uint object at 0x7ff2fc1fc200> # may vary | >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_uint32)).contents | c_uint(0) | >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_uint64)).contents | c_ulong(4294967296) | >>> x.ctypes.shape | <numpy.core._internal.c_long_Array_2 object at 0x7ff2fc1fce60> # may vary | >>> x.ctypes.strides | <numpy.core._internal.c_long_Array_2 object at 0x7ff2fc1ff320> # may vary | | 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. | WRITEBACKIFCOPY (X) | This array is a copy of some other array. The C-API function | PyArray_ResolveWritebackIfCopy must be called before deallocating | to the base array will be updated with the contents of this array. | UPDATEIFCOPY (U) | (Deprecated, use WRITEBACKIFCOPY) 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 WRITEBACKIFCOPY, 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``. | - WRITEBACKIFCOPY 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) | <class '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. | | The shape property is usually used to get the current shape of an array, | but may also be used to reshape the array in-place by assigning a tuple of | array dimensions to it. As with `numpy.reshape`, one of the new shape | dimensions can be -1, in which case its value is inferred from the size of | the array and the remaining dimensions. Reshaping an array in-place will | fail if a copy is required. | | 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 | >>> np.zeros((4,2))[::2].shape = (-1,) | Traceback (most recent call last): | File "<stdin>", line 1, in <module> | AttributeError: Incompatible shape for in-place modification. Use | `.reshape()` to make a copy with the desired shape. | | See Also | -------- | numpy.reshape : similar function | ndarray.reshape : similar method | | size | Number of elements in the array. | | Equal to ``np.prod(a.shape)``, i.e., the product of the array's | dimensions. | | Notes | ----- | `a.size` returns a standard arbitrary precision Python integer. This | may not be the case with other methods of obtaining the same value | (like the suggested ``np.prod(a.shape)``, which returns an instance | of ``np.int_``), and may be relevant if the value is used further in | calculations that may overflow a fixed size integer type. | | Examples | -------- | >>> x = np.zeros((3, 5, 2), dtype=np.complex128) | >>> x.size | 30 | >>> np.prod(x.shape) | 30 | | strides | Tuple of bytes to step in each dimension when traversing an array. | | The byte offset of element ``(i[0], i[1], ..., i[n])`` in an array `a` | is:: | | offset = sum(np.array(i) * a.strides) | | A more detailed explanation of strides can be found in the | "ndarray.rst" file in the NumPy reference guide. | | Notes | ----- | Imagine an array of 32-bit integers (each 4 bytes):: | | x = np.array([[0, 1, 2, 3, 4], | [5, 6, 7, 8, 9]], dtype=np.int32) | | This array is stored in memory as 40 bytes, one after the other | (known as a contiguous block of memory). The strides of an array tell | us how many bytes we have to skip in memory to move to the next position | along a certain axis. For example, we have to skip 4 bytes (1 value) to | move to the next column, but 20 bytes (5 values) to get to the same | position in the next row. As such, the strides for the array `x` will be | ``(20, 4)``. | | See Also | -------- | numpy.lib.stride_tricks.as_strided | | Examples | -------- | >>> y = np.reshape(np.arange(2*3*4), (2,3,4)) | >>> y | array([[[ 0, 1, 2, 3], | [ 4, 5, 6, 7], | [ 8, 9, 10, 11]], | [[12, 13, 14, 15], | [16, 17, 18, 19], | [20, 21, 22, 23]]]) | >>> y.strides | (48, 16, 4) | >>> y[1,1,1] | 17 | >>> offset=sum(y.strides * np.array((1,1,1))) | >>> offset/y.itemsize | 17 | | >>> x = np.reshape(np.arange(5*6*7*8), (5,6,7,8)).transpose(2,3,1,0) | >>> x.strides | (32, 4, 224, 1344) | >>> i = np.array([3,5,2,2]) | >>> offset = sum(i * x.strides) | >>> x[3,5,2,2] | 813 | >>> offset / x.itemsize | 813 | | ---------------------------------------------------------------------- | Data and other attributes defined here: | | __hash__ = None class ndenumerate(builtins.object) | ndenumerate(arr) | | Multidimensional index iterator. | | Return an iterator yielding pairs of array coordinates and values. | | Parameters | ---------- | arr : ndarray | Input array. | | See Also | -------- | ndindex, flatiter | | Examples | -------- | >>> a = np.array([[1, 2], [3, 4]]) | >>> for index, x in np.ndenumerate(a): | ... print(index, x) | (0, 0) 1 | (0, 1) 2 | (1, 0) 3 | (1, 1) 4 | | Methods defined here: | | __init__(self, arr) | Initialize self. See help(type(self)) for accurate signature. | | __iter__(self) | | __next__(self) | Standard iterator method, returns the index tuple and array value. | | Returns | ------- | coords : tuple of ints | The indices of the current iteration. | val : scalar | The array element of the current iteration. | | ---------------------------------------------------------------------- | Data descriptors defined here: | | __dict__ | dictionary for instance variables (if defined) | | __weakref__ | list of weak references to the object (if defined) class ndindex(builtins.object) | ndindex(*shape) | | An N-dimensional iterator object to index arrays. | | Given the shape of an array, an `ndindex` instance iterates over | the N-dimensional index of the array. At each iteration a tuple | of indices is returned, the last dimension is iterated over first. | | Parameters | ---------- | `*args` : ints | The size of each dimension of the array. | | See Also | -------- | ndenumerate, flatiter | | Examples | -------- | >>> for index in np.ndindex(3, 2, 1): | ... print(index) | (0, 0, 0) | (0, 1, 0) | (1, 0, 0) | (1, 1, 0) | (2, 0, 0) | (2, 1, 0) | | Methods defined here: | | __init__(self, *shape) | Initialize self. See help(type(self)) for accurate signature. | | __iter__(self) | | __next__(self) | Standard iterator method, updates the index and returns the index | tuple. | | Returns | ------- | val : tuple of ints | Returns a tuple containing the indices of the current | iteration. | | ndincr(self) | Increment the multi-dimensional index by one. | | This method is for backward compatibility only: do not use. | | ---------------------------------------------------------------------- | Data descriptors defined here: | | __dict__ | dictionary for instance variables (if defined) | | __weakref__ | list of weak references to the object (if defined) class nditer(builtins.object) | nditer(op, flags=None, op_flags=None, op_dtypes=None, order='K', casting='safe', op_axes=None, itershape=None, buffersize=0) | | Efficient multi-dimensional iterator object to iterate over arrays. | To get started using this object, see the | :ref:`introductory guide to array iteration <arrays.nditer>`. | | Parameters | ---------- | op : ndarray or sequence of array_like | The array(s) to iterate over. | | flags : sequence of str, optional | Flags to control the behavior of the iterator. | | * ``buffered`` enables buffering when required. | * ``c_index`` causes a C-order index to be tracked. | * ``f_index`` causes a Fortran-order index to be tracked. | * ``multi_index`` causes a multi-index, or a tuple of indices | with one per iteration dimension, to be tracked. | * ``common_dtype`` causes all the operands to be converted to | a common data type, with copying or buffering as necessary. | * ``copy_if_overlap`` causes the iterator to determine if read | operands have overlap with write operands, and make temporary | copies as necessary to avoid overlap. False positives (needless | copying) are possible in some cases. | * ``delay_bufalloc`` delays allocation of the buffers until | a reset() call is made. Allows ``allocate`` operands to | be initialized before their values are copied into the buffers. | * ``external_loop`` causes the ``values`` given to be | one-dimensional arrays with multiple values instead of | zero-dimensional arrays. | * ``grow_inner`` allows the ``value`` array sizes to be made | larger than the buffer size when both ``buffered`` and | ``external_loop`` is used. | * ``ranged`` allows the iterator to be restricted to a sub-range | of the iterindex values. | * ``refs_ok`` enables iteration of reference types, such as | object arrays. | * ``reduce_ok`` enables iteration of ``readwrite`` operands | which are broadcasted, also known as reduction operands. | * ``zerosize_ok`` allows `itersize` to be zero. | op_flags : list of list of str, optional | This is a list of flags for each operand. At minimum, one of | ``readonly``, ``readwrite``, or ``writeonly`` must be specified. | | * ``readonly`` indicates the operand will only be read from. | * ``readwrite`` indicates the operand will be read from and written to. | * ``writeonly`` indicates the operand will only be written to. | * ``no_broadcast`` prevents the operand from being broadcasted. | * ``contig`` forces the operand data to be contiguous. | * ``aligned`` forces the operand data to be aligned. | * ``nbo`` forces the operand data to be in native byte order. | * ``copy`` allows a temporary read-only copy if required. | * ``updateifcopy`` allows a temporary read-write copy if required. | * ``allocate`` causes the array to be allocated if it is None | in the ``op`` parameter. | * ``no_subtype`` prevents an ``allocate`` operand from using a subtype. | * ``arraymask`` indicates that this operand is the mask to use | for selecting elements when writing to operands with the | 'writemasked' flag set. The iterator does not enforce this, | but when writing from a buffer back to the array, it only | copies those elements indicated by this mask. | * ``writemasked`` indicates that only elements where the chosen | ``arraymask`` operand is True will be written to. | * ``overlap_assume_elementwise`` can be used to mark operands that are | accessed only in the iterator order, to allow less conservative | copying when ``copy_if_overlap`` is present. | op_dtypes : dtype or tuple of dtype(s), optional | The required data type(s) of the operands. If copying or buffering | is enabled, the data will be converted to/from their original types. | order : {'C', 'F', 'A', 'K'}, optional | Controls the iteration order. 'C' means C order, 'F' means | Fortran order, 'A' means 'F' order if all the arrays are Fortran | contiguous, 'C' order otherwise, and 'K' means as close to the | order the array elements appear in memory as possible. This also | affects the element memory order of ``allocate`` operands, as they | are allocated to be compatible with iteration order. | Default is 'K'. | casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional | Controls what kind of data casting may occur when making a copy | or buffering. Setting this to 'unsafe' is not recommended, | as it can adversely affect accumulations. | | * 'no' means the data types should not be cast at all. | * 'equiv' means only byte-order changes are allowed. | * 'safe' means only casts which can preserve values are allowed. | * 'same_kind' means only safe casts or casts within a kind, | like float64 to float32, are allowed. | * 'unsafe' means any data conversions may be done. | op_axes : list of list of ints, optional | If provided, is a list of ints or None for each operands. | The list of axes for an operand is a mapping from the dimensions | of the iterator to the dimensions of the operand. A value of | -1 can be placed for entries, causing that dimension to be | treated as `newaxis`. | itershape : tuple of ints, optional | The desired shape of the iterator. This allows ``allocate`` operands | with a dimension mapped by op_axes not corresponding to a dimension | of a different operand to get a value not equal to 1 for that | dimension. | buffersize : int, optional | When buffering is enabled, controls the size of the temporary | buffers. Set to 0 for the default value. | | Attributes | ---------- | dtypes : tuple of dtype(s) | The data types of the values provided in `value`. This may be | different from the operand data types if buffering is enabled. | Valid only before the iterator is closed. | finished : bool | Whether the iteration over the operands is finished or not. | has_delayed_bufalloc : bool | If True, the iterator was created with the ``delay_bufalloc`` flag, | and no reset() function was called on it yet. | has_index : bool | If True, the iterator was created with either the ``c_index`` or | the ``f_index`` flag, and the property `index` can be used to | retrieve it. | has_multi_index : bool | If True, the iterator was created with the ``multi_index`` flag, | and the property `multi_index` can be used to retrieve it. | index | When the ``c_index`` or ``f_index`` flag was used, this property | provides access to the index. Raises a ValueError if accessed | and ``has_index`` is False. | iterationneedsapi : bool | Whether iteration requires access to the Python API, for example | if one of the operands is an object array. | iterindex : int | An index which matches the order of iteration. | itersize : int | Size of the iterator. | itviews | Structured view(s) of `operands` in memory, matching the reordered | and optimized iterator access pattern. Valid only before the iterator | is closed. | multi_index | When the ``multi_index`` flag was used, this property | provides access to the index. Raises a ValueError if accessed | accessed and ``has_multi_index`` is False. | ndim : int | The dimensions of the iterator. | nop : int | The number of iterator operands. | operands : tuple of operand(s) | The array(s) to be iterated over. Valid only before the iterator is | closed. | shape : tuple of ints | Shape tuple, the shape of the iterator. | value | Value of ``operands`` at current iteration. Normally, this is a | tuple of array scalars, but if the flag ``external_loop`` is used, | it is a tuple of one dimensional arrays. | | Notes | ----- | `nditer` supersedes `flatiter`. The iterator implementation behind | `nditer` is also exposed by the NumPy C API. | | The Python exposure supplies two iteration interfaces, one which follows | the Python iterator protocol, and another which mirrors the C-style | do-while pattern. The native Python approach is better in most cases, but | if you need the coordinates or index of an iterator, use the C-style pattern. | | Examples | -------- | Here is how we might write an ``iter_add`` function, using the | Python iterator protocol: | | >>> def iter_add_py(x, y, out=None): | ... addop = np.add | ... it = np.nditer([x, y, out], [], | ... [['readonly'], ['readonly'], ['writeonly','allocate']]) | ... with it: | ... for (a, b, c) in it: | ... addop(a, b, out=c) | ... return it.operands[2] | | Here is the same function, but following the C-style pattern: | | >>> def iter_add(x, y, out=None): | ... addop = np.add | ... it = np.nditer([x, y, out], [], | ... [['readonly'], ['readonly'], ['writeonly','allocate']]) | ... with it: | ... while not it.finished: | ... addop(it[0], it[1], out=it[2]) | ... it.iternext() | ... return it.operands[2] | | Here is an example outer product function: | | >>> def outer_it(x, y, out=None): | ... mulop = np.multiply | ... it = np.nditer([x, y, out], ['external_loop'], | ... [['readonly'], ['readonly'], ['writeonly', 'allocate']], | ... op_axes=[list(range(x.ndim)) + [-1] * y.ndim, | ... [-1] * x.ndim + list(range(y.ndim)), | ... None]) | ... with it: | ... for (a, b, c) in it: | ... mulop(a, b, out=c) | ... return it.operands[2] | | >>> a = np.arange(2)+1 | >>> b = np.arange(3)+1 | >>> outer_it(a,b) | array([[1, 2, 3], | [2, 4, 6]]) | | Here is an example function which operates like a "lambda" ufunc: | | >>> def luf(lamdaexpr, *args, **kwargs): | ... '''luf(lambdaexpr, op1, ..., opn, out=None, order='K', casting='safe', buffersize=0)''' | ... nargs = len(args) | ... op = (kwargs.get('out',None),) + args | ... it = np.nditer(op, ['buffered','external_loop'], | ... [['writeonly','allocate','no_broadcast']] + | ... [['readonly','nbo','aligned']]*nargs, | ... order=kwargs.get('order','K'), | ... casting=kwargs.get('casting','safe'), | ... buffersize=kwargs.get('buffersize',0)) | ... while not it.finished: | ... it[0] = lamdaexpr(*it[1:]) | ... it.iternext() | ... return it.operands[0] | | >>> a = np.arange(5) | >>> b = np.ones(5) | >>> luf(lambda i,j:i*i + j/2, a, b) | array([ 0.5, 1.5, 4.5, 9.5, 16.5]) | | If operand flags `"writeonly"` or `"readwrite"` are used the | operands may be views into the original data with the | `WRITEBACKIFCOPY` flag. In this case `nditer` must be used as a | context manager or the `nditer.close` method must be called before | using the result. The temporary data will be written back to the | original data when the `__exit__` function is called but not before: | | >>> a = np.arange(6, dtype='i4')[::-2] | >>> with np.nditer(a, [], | ... [['writeonly', 'updateifcopy']], | ... casting='unsafe', | ... op_dtypes=[np.dtype('f4')]) as i: | ... x = i.operands[0] | ... x[:] = [-1, -2, -3] | ... # a still unchanged here | >>> a, x | (array([-1, -2, -3], dtype=int32), array([-1., -2., -3.], dtype=float32)) | | It is important to note that once the iterator is exited, dangling | references (like `x` in the example) may or may not share data with | the original data `a`. If writeback semantics were active, i.e. if | `x.base.flags.writebackifcopy` is `True`, then exiting the iterator | will sever the connection between `x` and `a`, writing to `x` will | no longer write to `a`. If writeback semantics are not active, then | `x.data` will still point at some part of `a.data`, and writing to | one will affect the other. | | Context management and the `close` method appeared in version 1.15.0. | | Methods defined here: | | __copy__(...) | | __delitem__(self, key, /) | Delete self[key]. | | __enter__(...) | | __exit__(...) | | __getitem__(self, key, /) | Return self[key]. | | __init__(self, /, *args, **kwargs) | Initialize self. See help(type(self)) for accurate signature. | | __iter__(self, /) | Implement iter(self). | | __len__(self, /) | Return len(self). | | __next__(self, /) | Implement next(self). | | __setitem__(self, key, value, /) | Set self[key] to value. | | close(...) | close() | | Resolve all writeback semantics in writeable operands. | | .. versionadded:: 1.15.0 | | See Also | -------- | | :ref:`nditer-context-manager` | | copy(...) | copy() | | Get a copy of the iterator in its current state. | | Examples | -------- | >>> x = np.arange(10) | >>> y = x + 1 | >>> it = np.nditer([x, y]) | >>> next(it) | (array(0), array(1)) | >>> it2 = it.copy() | >>> next(it2) | (array(1), array(2)) | | debug_print(...) | debug_print() | | Print the current state of the `nditer` instance and debug info to stdout. | | enable_external_loop(...) | enable_external_loop() | | When the "external_loop" was not used during construction, but | is desired, this modifies the iterator to behave as if the flag | was specified. | | iternext(...) | iternext() | | Check whether iterations are left, and perform a single internal iteration | without returning the result. Used in the C-style pattern do-while | pattern. For an example, see `nditer`. | | Returns | ------- | iternext : bool | Whether or not there are iterations left. | | remove_axis(...) | remove_axis(i) | | Removes axis `i` from the iterator. Requires that the flag "multi_index" | be enabled. | | remove_multi_index(...) | remove_multi_index() | | When the "multi_index" flag was specified, this removes it, allowing | the internal iteration structure to be optimized further. | | reset(...) | reset() | | Reset the iterator to its initial state. | | ---------------------------------------------------------------------- | Static methods defined here: | | __new__(*args, **kwargs) from builtins.type | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Data descriptors defined here: | | dtypes | | finished | | has_delayed_bufalloc | | has_index | | has_multi_index | | index | | iterationneedsapi | | iterindex | | iterrange | | itersize | | itviews | | multi_index | | ndim | | nop | | operands | operands[`Slice`] | | The array(s) to be iterated over. Valid only before the iterator is closed. | | shape | | value class number(generic) | Abstract base class of all numeric scalar types. | | Method resolution order: | number | generic | builtins.object | | Methods inherited from generic: | | __abs__(self, /) | abs(self) | | __add__(self, value, /) | Return self+value. | | __and__(self, value, /) | Return self&value. | | __array__(...) | sc.__array__(dtype) return 0-dim array from scalar with specified dtype | | __array_wrap__(...) | sc.__array_wrap__(obj) return scalar from array | | __bool__(self, /) | self != 0 | | __copy__(...) | | __deepcopy__(...) | | __divmod__(self, value, /) | Return divmod(self, value). | | __eq__(self, value, /) | Return self==value. | | __float__(self, /) | float(self) | | __floordiv__(self, value, /) | Return self//value. | | __format__(...) | NumPy array scalar formatter | | __ge__(self, value, /) | Return self>=value. | | __getitem__(self, key, /) | Return self[key]. | | __gt__(self, value, /) | Return self>value. | | __int__(self, /) | int(self) | | __invert__(self, /) | ~self | | __le__(self, value, /) | Return self<=value. | | __lshift__(self, value, /) | Return self<<value. | | __lt__(self, value, /) | Return self<value. | | __mod__(self, value, /) | Return self%value. | | __mul__(self, value, /) | Return self*value. | | __ne__(self, value, /) | Return self!=value. | | __neg__(self, /) | -self | | __or__(self, value, /) | Return self|value. | | __pos__(self, /) | +self | | __pow__(self, value, mod=None, /) | Return pow(self, value, mod). | | __radd__(self, value, /) | Return value+self. | | __rand__(self, value, /) | Return value&self. | | __rdivmod__(self, value, /) | Return divmod(value, self). | | __reduce__(...) | Helper for pickle. | | __rfloordiv__(self, value, /) | Return value//self. | | __rlshift__(self, value, /) | Return value<<self. | | __rmod__(self, value, /) | Return value%self. | | __rmul__(self, value, /) | Return value*self. | | __ror__(self, value, /) | Return value|self. | | __rpow__(self, value, mod=None, /) | Return pow(value, self, mod). | | __rrshift__(self, value, /) | Return value>>self. | | __rshift__(self, value, /) | Return self>>value. | | __rsub__(self, value, /) | Return value-self. | | __rtruediv__(self, value, /) | Return value/self. | | __rxor__(self, value, /) | Return value^self. | | __setstate__(...) | | __sizeof__(...) | Size of object in memory, in bytes. | | __sub__(self, value, /) | Return self-value. | | __truediv__(self, value, /) | Return self/value. | | __xor__(self, value, /) | Return self^value. | | all(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | getfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | base | base object | | data | pointer to start of data | | dtype | get array data-descriptor | | flags | integer value of flags | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension | | ---------------------------------------------------------------------- | Data and other attributes inherited from generic: | | __hash__ = None object0 = class object_(generic) | Any Python object. | Character code: ``'O'``. | | Method resolution order: | object_ | generic | builtins.object | | Methods defined here: | | __add__(self, value, /) | Return self+value. | | __call__(self, /, *args, **kwargs) | Call self as a function. | | __contains__(self, key, /) | Return key in self. | | __delattr__(self, name, /) | Implement delattr(self, name). | | __delitem__(self, key, /) | Delete self[key]. | | __eq__(self, value, /) | Return self==value. | | __ge__(self, value, /) | Return self>=value. | | __getattribute__(self, name, /) | Return getattr(self, name). | | __getitem__(self, key, /) | Return self[key]. | | __gt__(self, value, /) | Return self>value. | | __hash__(self, /) | Return hash(self). | | __iadd__(self, value, /) | Implement self+=value. | | __imul__(self, value, /) | Implement self*=value. | | __le__(self, value, /) | Return self<=value. | | __len__(self, /) | Return len(self). | | __lt__(self, value, /) | Return self<value. | | __mul__(self, value, /) | Return self*value. | | __ne__(self, value, /) | Return self!=value. | | __rmul__(self, value, /) | Return value*self. | | __setattr__(self, name, value, /) | Implement setattr(self, name, value). | | __setitem__(self, key, value, /) | Set self[key] to value. | | ---------------------------------------------------------------------- | Static methods defined here: | | __new__(*args, **kwargs) from builtins.type | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Methods inherited from generic: | | __abs__(self, /) | abs(self) | | __and__(self, value, /) | Return self&value. | | __array__(...) | sc.__array__(dtype) return 0-dim array from scalar with specified dtype | | __array_wrap__(...) | sc.__array_wrap__(obj) return scalar from array | | __bool__(self, /) | self != 0 | | __copy__(...) | | __deepcopy__(...) | | __divmod__(self, value, /) | Return divmod(self, value). | | __float__(self, /) | float(self) | | __floordiv__(self, value, /) | Return self//value. | | __format__(...) | NumPy array scalar formatter | | __int__(self, /) | int(self) | | __invert__(self, /) | ~self | | __lshift__(self, value, /) | Return self<<value. | | __mod__(self, value, /) | Return self%value. | | __neg__(self, /) | -self | | __or__(self, value, /) | Return self|value. | | __pos__(self, /) | +self | | __pow__(self, value, mod=None, /) | Return pow(self, value, mod). | | __radd__(self, value, /) | Return value+self. | | __rand__(self, value, /) | Return value&self. | | __rdivmod__(self, value, /) | Return divmod(value, self). | | __reduce__(...) | Helper for pickle. | | __rfloordiv__(self, value, /) | Return value//self. | | __rlshift__(self, value, /) | Return value<<self. | | __rmod__(self, value, /) | Return value%self. | | __ror__(self, value, /) | Return value|self. | | __rpow__(self, value, mod=None, /) | Return pow(value, self, mod). | | __rrshift__(self, value, /) | Return value>>self. | | __rshift__(self, value, /) | Return self>>value. | | __rsub__(self, value, /) | Return value-self. | | __rtruediv__(self, value, /) | Return value/self. | | __rxor__(self, value, /) | Return value^self. | | __setstate__(...) | | __sizeof__(...) | Size of object in memory, in bytes. | | __sub__(self, value, /) | Return self-value. | | __truediv__(self, value, /) | Return self/value. | | __xor__(self, value, /) | Return self^value. | | all(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | getfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | base | base object | | data | pointer to start of data | | dtype | get array data-descriptor | | flags | integer value of flags | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension class object_(generic) | Any Python object. | Character code: ``'O'``. | | Method resolution order: | object_ | generic | builtins.object | | Methods defined here: | | __add__(self, value, /) | Return self+value. | | __call__(self, /, *args, **kwargs) | Call self as a function. | | __contains__(self, key, /) | Return key in self. | | __delattr__(self, name, /) | Implement delattr(self, name). | | __delitem__(self, key, /) | Delete self[key]. | | __eq__(self, value, /) | Return self==value. | | __ge__(self, value, /) | Return self>=value. | | __getattribute__(self, name, /) | Return getattr(self, name). | | __getitem__(self, key, /) | Return self[key]. | | __gt__(self, value, /) | Return self>value. | | __hash__(self, /) | Return hash(self). | | __iadd__(self, value, /) | Implement self+=value. | | __imul__(self, value, /) | Implement self*=value. | | __le__(self, value, /) | Return self<=value. | | __len__(self, /) | Return len(self). | | __lt__(self, value, /) | Return self<value. | | __mul__(self, value, /) | Return self*value. | | __ne__(self, value, /) | Return self!=value. | | __rmul__(self, value, /) | Return value*self. | | __setattr__(self, name, value, /) | Implement setattr(self, name, value). | | __setitem__(self, key, value, /) | Set self[key] to value. | | ---------------------------------------------------------------------- | Static methods defined here: | | __new__(*args, **kwargs) from builtins.type | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Methods inherited from generic: | | __abs__(self, /) | abs(self) | | __and__(self, value, /) | Return self&value. | | __array__(...) | sc.__array__(dtype) return 0-dim array from scalar with specified dtype | | __array_wrap__(...) | sc.__array_wrap__(obj) return scalar from array | | __bool__(self, /) | self != 0 | | __copy__(...) | | __deepcopy__(...) | | __divmod__(self, value, /) | Return divmod(self, value). | | __float__(self, /) | float(self) | | __floordiv__(self, value, /) | Return self//value. | | __format__(...) | NumPy array scalar formatter | | __int__(self, /) | int(self) | | __invert__(self, /) | ~self | | __lshift__(self, value, /) | Return self<<value. | | __mod__(self, value, /) | Return self%value. | | __neg__(self, /) | -self | | __or__(self, value, /) | Return self|value. | | __pos__(self, /) | +self | | __pow__(self, value, mod=None, /) | Return pow(self, value, mod). | | __radd__(self, value, /) | Return value+self. | | __rand__(self, value, /) | Return value&self. | | __rdivmod__(self, value, /) | Return divmod(value, self). | | __reduce__(...) | Helper for pickle. | | __rfloordiv__(self, value, /) | Return value//self. | | __rlshift__(self, value, /) | Return value<<self. | | __rmod__(self, value, /) | Return value%self. | | __ror__(self, value, /) | Return value|self. | | __rpow__(self, value, mod=None, /) | Return pow(value, self, mod). | | __rrshift__(self, value, /) | Return value>>self. | | __rshift__(self, value, /) | Return self>>value. | | __rsub__(self, value, /) | Return value-self. | | __rtruediv__(self, value, /) | Return value/self. | | __rxor__(self, value, /) | Return value^self. | | __setstate__(...) | | __sizeof__(...) | Size of object in memory, in bytes. | | __sub__(self, value, /) | Return self-value. | | __truediv__(self, value, /) | Return self/value. | | __xor__(self, value, /) | Return self^value. | | all(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | getfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | base | base object | | data | pointer to start of data | | dtype | get array data-descriptor | | flags | integer value of flags | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension class poly1d(builtins.object) | poly1d(c_or_r, r=False, variable=None) | | A one-dimensional polynomial class. | | A convenience class, used to encapsulate "natural" operations on | polynomials so that said operations may take on their customary | form in code (see Examples). | | Parameters | ---------- | c_or_r : array_like | The polynomial's coefficients, in decreasing powers, or if | the value of the second parameter is True, the polynomial's | roots (values where the polynomial evaluates to 0). For example, | ``poly1d([1, 2, 3])`` returns an object that represents | :math:`x^2 + 2x + 3`, whereas ``poly1d([1, 2, 3], True)`` returns | one that represents :math:`(x-1)(x-2)(x-3) = x^3 - 6x^2 + 11x -6`. | r : bool, optional | If True, `c_or_r` specifies the polynomial's roots; the default | is False. | variable : str, optional | Changes the variable used when printing `p` from `x` to `variable` | (see Examples). | | Examples | -------- | Construct the polynomial :math:`x^2 + 2x + 3`: | | >>> p = np.poly1d([1, 2, 3]) | >>> print(np.poly1d(p)) | 2 | 1 x + 2 x + 3 | | Evaluate the polynomial at :math:`x = 0.5`: | | >>> p(0.5) | 4.25 | | Find the roots: | | >>> p.r | array([-1.+1.41421356j, -1.-1.41421356j]) | >>> p(p.r) | array([ -4.44089210e-16+0.j, -4.44089210e-16+0.j]) # may vary | | These numbers in the previous line represent (0, 0) to machine precision | | Show the coefficients: | | >>> p.c | array([1, 2, 3]) | | Display the order (the leading zero-coefficients are removed): | | >>> p.order | 2 | | Show the coefficient of the k-th power in the polynomial | (which is equivalent to ``p.c[-(i+1)]``): | | >>> p[1] | 2 | | Polynomials can be added, subtracted, multiplied, and divided | (returns quotient and remainder): | | >>> p * p | poly1d([ 1, 4, 10, 12, 9]) | | >>> (p**3 + 4) / p | (poly1d([ 1., 4., 10., 12., 9.]), poly1d([4.])) | | ``asarray(p)`` gives the coefficient array, so polynomials can be | used in all functions that accept arrays: | | >>> p**2 # square of polynomial | poly1d([ 1, 4, 10, 12, 9]) | | >>> np.square(p) # square of individual coefficients | array([1, 4, 9]) | | The variable used in the string representation of `p` can be modified, | using the `variable` parameter: | | >>> p = np.poly1d([1,2,3], variable='z') | >>> print(p) | 2 | 1 z + 2 z + 3 | | Construct a polynomial from its roots: | | >>> np.poly1d([1, 2], True) | poly1d([ 1., -3., 2.]) | | This is the same polynomial as obtained by: | | >>> np.poly1d([1, -1]) * np.poly1d([1, -2]) | poly1d([ 1, -3, 2]) | | Methods defined here: | | __add__(self, other) | | __array__(self, t=None) | | __call__(self, val) | Call self as a function. | | __div__(self, other) | | __eq__(self, other) | Return self==value. | | __getitem__(self, val) | | __init__(self, c_or_r, r=False, variable=None) | Initialize self. See help(type(self)) for accurate signature. | | __iter__(self) | | __len__(self) | | __mul__(self, other) | | __ne__(self, other) | Return self!=value. | | __neg__(self) | | __pos__(self) | | __pow__(self, val) | | __radd__(self, other) | | __rdiv__(self, other) | | __repr__(self) | Return repr(self). | | __rmul__(self, other) | | __rsub__(self, other) | | __rtruediv__ = __rdiv__(self, other) | | __setitem__(self, key, val) | | __str__(self) | Return str(self). | | __sub__(self, other) | | __truediv__ = __div__(self, other) | | deriv(self, m=1) | Return a derivative of this polynomial. | | Refer to `polyder` for full documentation. | | See Also | -------- | polyder : equivalent function | | integ(self, m=1, k=0) | Return an antiderivative (indefinite integral) of this polynomial. | | Refer to `polyint` for full documentation. | | See Also | -------- | polyint : equivalent function | | ---------------------------------------------------------------------- | Readonly properties defined here: | | o | The order or degree of the polynomial | | order | The order or degree of the polynomial | | r | The roots of the polynomial, where self(x) == 0 | | roots | The roots of the polynomial, where self(x) == 0 | | variable | The name of the polynomial variable | | ---------------------------------------------------------------------- | Data descriptors defined here: | | __dict__ | dictionary for instance variables (if defined) | | __weakref__ | list of weak references to the object (if defined) | | c | The polynomial coefficients | | coef | The polynomial coefficients | | coefficients | The polynomial coefficients | | coeffs | The polynomial coefficients | | ---------------------------------------------------------------------- | Data and other attributes defined here: | | __hash__ = None class recarray(ndarray) | recarray(shape, dtype=None, buf=None, offset=0, strides=None, formats=None, names=None, titles=None, byteorder=None, aligned=False, order='C') | | Construct an ndarray that allows field access using attributes. | | Arrays may have a data-types containing fields, analogous | to columns in a spread sheet. An example is ``[(x, int), (y, float)]``, | where each entry in the array is a pair of ``(int, float)``. Normally, | these attributes are accessed using dictionary lookups such as ``arr['x']`` | and ``arr['y']``. Record arrays allow the fields to be accessed as members | of the array, using ``arr.x`` and ``arr.y``. | | Parameters | ---------- | shape : tuple | Shape of output array. | dtype : data-type, optional | The desired data-type. By default, the data-type is determined | from `formats`, `names`, `titles`, `aligned` and `byteorder`. | formats : list of data-types, optional | A list containing the data-types for the different columns, e.g. | ``['i4', 'f8', 'i4']``. `formats` does *not* support the new | convention of using types directly, i.e. ``(int, float, int)``. | Note that `formats` must be a list, not a tuple. | Given that `formats` is somewhat limited, we recommend specifying | `dtype` instead. | names : tuple of str, optional | The name of each column, e.g. ``('x', 'y', 'z')``. | buf : buffer, optional | By default, a new array is created of the given shape and data-type. | If `buf` is specified and is an object exposing the buffer interface, | the array will use the memory from the existing buffer. In this case, | the `offset` and `strides` keywords are available. | | Other Parameters | ---------------- | titles : tuple of str, optional | Aliases for column names. For example, if `names` were | ``('x', 'y', 'z')`` and `titles` is | ``('x_coordinate', 'y_coordinate', 'z_coordinate')``, then | ``arr['x']`` is equivalent to both ``arr.x`` and ``arr.x_coordinate``. | byteorder : {'<', '>', '='}, optional | Byte-order for all fields. | aligned : bool, optional | Align the fields in memory as the C-compiler would. | strides : tuple of ints, optional | Buffer (`buf`) is interpreted according to these strides (strides | define how many bytes each array element, row, column, etc. | occupy in memory). | offset : int, optional | Start reading buffer (`buf`) from this offset onwards. | order : {'C', 'F'}, optional | Row-major (C-style) or column-major (Fortran-style) order. | | Returns | ------- | rec : recarray | Empty array of the given shape and type. | | See Also | -------- | rec.fromrecords : Construct a record array from data. | record : fundamental data-type for `recarray`. | format_parser : determine a data-type from formats, names, titles. | | Notes | ----- | This constructor can be compared to ``empty``: it creates a new record | array but does not fill it with data. To create a record array from data, | use one of the following methods: | | 1. Create a standard ndarray and convert it to a record array, | using ``arr.view(np.recarray)`` | 2. Use the `buf` keyword. | 3. Use `np.rec.fromrecords`. | | Examples | -------- | Create an array with two fields, ``x`` and ``y``: | | >>> x = np.array([(1.0, 2), (3.0, 4)], dtype=[('x', '<f8'), ('y', '<i8')]) | >>> x | array([(1., 2), (3., 4)], dtype=[('x', '<f8'), ('y', '<i8')]) | | >>> x['x'] | array([1., 3.]) | | View the array as a record array: | | >>> x = x.view(np.recarray) | | >>> x.x | array([1., 3.]) | | >>> x.y | array([2, 4]) | | Create a new, empty record array: | | >>> np.recarray((2,), | ... dtype=[('x', int), ('y', float), ('z', int)]) #doctest: +SKIP | rec.array([(-1073741821, 1.2249118382103472e-301, 24547520), | (3471280, 1.2134086255804012e-316, 0)], | dtype=[('x', '<i4'), ('y', '<f8'), ('z', '<i4')]) | | Method resolution order: | recarray | ndarray | builtins.object | | Methods defined here: | | __array_finalize__(self, obj) | None. | | __getattribute__(self, attr) | Return getattr(self, name). | | __getitem__(self, indx) | Return self[key]. | | __repr__(self) | Return repr(self). | | __setattr__(self, attr, val) | Implement setattr(self, name, value). | | field(self, attr, val=None) | | ---------------------------------------------------------------------- | Static methods defined here: | | __new__(subtype, shape, dtype=None, buf=None, offset=0, strides=None, formats=None, names=None, titles=None, byteorder=None, aligned=False, order='C') | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Data descriptors defined here: | | __dict__ | dictionary for instance variables (if defined) | | ---------------------------------------------------------------------- | Methods inherited from ndarray: | | __abs__(self, /) | abs(self) | | __add__(self, value, /) | Return self+value. | | __and__(self, value, /) | Return self&value. | | __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_function__(...) | | __array_prepare__(...) | a.__array_prepare__(obj) -> Object of same type as ndarray object obj. | | __array_ufunc__(...) | | __array_wrap__(...) | a.__array_wrap__(obj) -> Object of same type as ndarray object a. | | __bool__(self, /) | self != 0 | | __complex__(...) | | __contains__(self, key, /) | Return key in self. | | __copy__(...) | a.__copy__() | | Used if :func:`copy.copy` is called on an array. Returns a copy of the array. | | Equivalent to ``a.copy(order='K')``. | | __deepcopy__(...) | a.__deepcopy__(memo, /) -> Deep copy of array. | | Used if :func:`copy.deepcopy` is called on an array. | | __delitem__(self, key, /) | Delete self[key]. | | __divmod__(self, value, /) | Return divmod(self, value). | | __eq__(self, value, /) | Return self==value. | | __float__(self, /) | float(self) | | __floordiv__(self, value, /) | Return self//value. | | __format__(...) | Default object formatter. | | __ge__(self, value, /) | Return self>=value. | | __gt__(self, value, /) | Return self>value. | | __iadd__(self, value, /) | Return self+=value. | | __iand__(self, value, /) | Return self&=value. | | __ifloordiv__(self, value, /) | Return self//=value. | | __ilshift__(self, value, /) | Return self<<=value. | | __imatmul__(self, value, /) | Return self@=value. | | __imod__(self, value, /) | Return self%=value. | | __imul__(self, value, /) | Return self*=value. | | __index__(self, /) | Return self converted to an integer, if self is suitable for use as an index into a list. | | __int__(self, /) | int(self) | | __invert__(self, /) | ~self | | __ior__(self, value, /) | Return self|=value. | | __ipow__(self, value, /) | Return self**=value. | | __irshift__(self, value, /) | Return self>>=value. | | __isub__(self, value, /) | Return self-=value. | | __iter__(self, /) | Implement iter(self). | | __itruediv__(self, value, /) | Return self/=value. | | __ixor__(self, value, /) | Return self^=value. | | __le__(self, value, /) | Return self<=value. | | __len__(self, /) | Return len(self). | | __lshift__(self, value, /) | Return self<<value. | | __lt__(self, value, /) | Return self<value. | | __matmul__(self, value, /) | Return self@value. | | __mod__(self, value, /) | Return self%value. | | __mul__(self, value, /) | Return self*value. | | __ne__(self, value, /) | Return self!=value. | | __neg__(self, /) | -self | | __or__(self, value, /) | Return self|value. | | __pos__(self, /) | +self | | __pow__(self, value, mod=None, /) | Return pow(self, value, mod). | | __radd__(self, value, /) | Return value+self. | | __rand__(self, value, /) | Return value&self. | | __rdivmod__(self, value, /) | Return divmod(value, self). | | __reduce__(...) | a.__reduce__() | | For pickling. | | __reduce_ex__(...) | Helper for pickle. | | __rfloordiv__(self, value, /) | Return value//self. | | __rlshift__(self, value, /) | Return value<<self. | | __rmatmul__(self, value, /) | Return value@self. | | __rmod__(self, value, /) | Return value%self. | | __rmul__(self, value, /) | Return value*self. | | __ror__(self, value, /) | Return value|self. | | __rpow__(self, value, mod=None, /) | Return pow(value, self, mod). | | __rrshift__(self, value, /) | Return value>>self. | | __rshift__(self, value, /) | Return self>>value. | | __rsub__(self, value, /) | Return value-self. | | __rtruediv__(self, value, /) | Return value/self. | | __rxor__(self, value, /) | Return value^self. | | __setitem__(self, key, value, /) | Set self[key] to value. | | __setstate__(...) | a.__setstate__(state, /) | | For unpickling. | | The `state` argument must be a sequence that contains the following | elements: | | Parameters | ---------- | version : int | optional pickle version. If omitted defaults to 0. | shape : tuple | dtype : data-type | isFortran : bool | rawdata : string or list | a binary string with the data (or a list if 'a' is an object array) | | __sizeof__(...) | Size of object in memory, in bytes. | | __str__(self, /) | Return str(self). | | __sub__(self, value, /) | Return self-value. | | __truediv__(self, value, /) | Return self/value. | | __xor__(self, value, /) | Return self^value. | | all(...) | a.all(axis=None, out=None, keepdims=False) | | Returns True if all elements evaluate to True. | | Refer to `numpy.all` for full documentation. | | See Also | -------- | numpy.all : equivalent function | | any(...) | a.any(axis=None, out=None, keepdims=False) | | Returns True if any of the elements of `a` evaluate to True. | | Refer to `numpy.any` for full documentation. | | See Also | -------- | numpy.any : equivalent function | | argmax(...) | a.argmax(axis=None, out=None) | | Return indices of the maximum values along the given axis. | | Refer to `numpy.argmax` for full documentation. | | See Also | -------- | numpy.argmax : equivalent function | | argmin(...) | a.argmin(axis=None, out=None) | | Return indices of the minimum values along the given axis of `a`. | | Refer to `numpy.argmin` for detailed documentation. | | See Also | -------- | numpy.argmin : equivalent function | | argpartition(...) | a.argpartition(kth, axis=-1, kind='introselect', order=None) | | Returns the indices that would partition this array. | | Refer to `numpy.argpartition` for full documentation. | | .. versionadded:: 1.8.0 | | See Also | -------- | numpy.argpartition : equivalent function | | argsort(...) | a.argsort(axis=-1, kind=None, order=None) | | Returns the indices that would sort this array. | | Refer to `numpy.argsort` for full documentation. | | See Also | -------- | numpy.argsort : equivalent function | | astype(...) | a.astype(dtype, order='K', casting='unsafe', subok=True, copy=True) | | Copy of the array, cast to a specified type. | | Parameters | ---------- | dtype : str or dtype | Typecode or data-type to which the array is cast. | order : {'C', 'F', 'A', 'K'}, optional | Controls the memory layout order of the result. | 'C' means C order, 'F' means Fortran order, 'A' | means 'F' order if all the arrays are Fortran contiguous, | 'C' order otherwise, and 'K' means as close to the | order the array elements appear in memory as possible. | Default is 'K'. | casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional | Controls what kind of data casting may occur. Defaults to 'unsafe' | for backwards compatibility. | | * 'no' means the data types should not be cast at all. | * 'equiv' means only byte-order changes are allowed. | * 'safe' means only casts which can preserve values are allowed. | * 'same_kind' means only safe casts or casts within a kind, | like float64 to float32, are allowed. | * 'unsafe' means any data conversions may be done. | subok : bool, optional | If True, then sub-classes will be passed-through (default), otherwise | the returned array will be forced to be a base-class array. | copy : bool, optional | By default, astype always returns a newly allocated array. If this | is set to false, and the `dtype`, `order`, and `subok` | requirements are satisfied, the input array is returned instead | of a copy. | | Returns | ------- | arr_t : ndarray | Unless `copy` is False and the other conditions for returning the input | array are satisfied (see description for `copy` input parameter), `arr_t` | is a new array of the same shape as the input array, with dtype, order | given by `dtype`, `order`. | | Notes | ----- | .. versionchanged:: 1.17.0 | Casting between a simple data type and a structured one is possible only | for "unsafe" casting. Casting to multiple fields is allowed, but | casting from multiple fields is not. | | .. versionchanged:: 1.9.0 | Casting from numeric to string types in 'safe' casting mode requires | that the string dtype length is long enough to store the max | integer/float value converted. | | 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=False) | | 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. | Arrays of byte-strings are not swapped. The real and imaginary | parts of a complex number are swapped individually. | | 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) | >>> list(map(hex, A)) | ['0x1', '0x100', '0x2233'] | >>> A.byteswap(inplace=True) | array([ 256, 1, 13090], dtype=int16) | >>> list(map(hex, A)) | ['0x100', '0x1', '0x3322'] | | Arrays of byte-strings are not swapped | | >>> A = np.array([b'ceg', b'fac']) | >>> A.byteswap() | array([b'ceg', b'fac'], dtype='|S3') | | ``A.newbyteorder().byteswap()`` produces an array with the same values | but different representation in memory | | >>> A = np.array([1, 2, 3]) | >>> A.view(np.uint8) | array([1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, | 0, 0], dtype=uint8) | >>> A.newbyteorder().byteswap(inplace=True) | array([1, 2, 3]) | >>> A.view(np.uint8) | array([0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, | 0, 3], dtype=uint8) | | choose(...) | a.choose(choices, out=None, mode='raise') | | Use an index array to construct a new array from a set of choices. | | Refer to `numpy.choose` for full documentation. | | See Also | -------- | numpy.choose : equivalent function | | clip(...) | a.clip(min=None, max=None, out=None, **kwargs) | | Return an array whose values are limited to ``[min, max]``. | One of max or min must be given. | | Refer to `numpy.clip` for full documentation. | | See Also | -------- | numpy.clip : equivalent function | | compress(...) | a.compress(condition, axis=None, out=None) | | Return selected slices of this array along given axis. | | Refer to `numpy.compress` for full documentation. | | See Also | -------- | numpy.compress : equivalent function | | conj(...) | a.conj() | | Complex-conjugate all elements. | | Refer to `numpy.conjugate` for full documentation. | | See Also | -------- | numpy.conjugate : equivalent function | | conjugate(...) | a.conjugate() | | Return the complex conjugate, element-wise. | | Refer to `numpy.conjugate` for full documentation. | | See Also | -------- | numpy.conjugate : equivalent function | | copy(...) | a.copy(order='C') | | Return a copy of the array. | | Parameters | ---------- | order : {'C', 'F', 'A', 'K'}, optional | Controls the memory layout of the copy. 'C' means C-order, | 'F' means F-order, 'A' means 'F' if `a` is Fortran contiguous, | 'C' otherwise. 'K' means match the layout of `a` as closely | as possible. (Note that this function and :func:`numpy.copy` are very | similar, but have different default values for their order= | arguments.) | | See also | -------- | numpy.copy | numpy.copyto | | Examples | -------- | >>> x = np.array([[1,2,3],[4,5,6]], order='F') | | >>> y = x.copy() | | >>> x.fill(0) | | >>> x | array([[0, 0, 0], | [0, 0, 0]]) | | >>> y | array([[1, 2, 3], | [4, 5, 6]]) | | >>> y.flags['C_CONTIGUOUS'] | True | | cumprod(...) | a.cumprod(axis=None, dtype=None, out=None) | | Return the cumulative product of the elements along the given axis. | | Refer to `numpy.cumprod` for full documentation. | | See Also | -------- | numpy.cumprod : equivalent function | | cumsum(...) | a.cumsum(axis=None, dtype=None, out=None) | | Return the cumulative sum of the elements along the given axis. | | Refer to `numpy.cumsum` for full documentation. | | See Also | -------- | numpy.cumsum : equivalent function | | diagonal(...) | a.diagonal(offset=0, axis1=0, axis2=1) | | Return specified diagonals. In NumPy 1.9 the returned array is a | read-only view instead of a copy as in previous NumPy versions. In | a future version the read-only restriction will be removed. | | Refer to :func:`numpy.diagonal` for full documentation. | | See Also | -------- | numpy.diagonal : equivalent function | | dot(...) | a.dot(b, out=None) | | Dot product of two arrays. | | Refer to `numpy.dot` for full documentation. | | See Also | -------- | numpy.dot : equivalent function | | Examples | -------- | >>> a = np.eye(2) | >>> b = np.ones((2, 2)) * 2 | >>> a.dot(b) | array([[2., 2.], | [2., 2.]]) | | This array method can be conveniently chained: | | >>> a.dot(b).dot(b) | array([[8., 8.], | [8., 8.]]) | | dump(...) | a.dump(file) | | Dump a pickle of the array to the specified file. | The array can be read back with pickle.load or numpy.load. | | Parameters | ---------- | file : str or Path | A string naming the dump file. | | .. versionchanged:: 1.17.0 | `pathlib.Path` objects are now accepted. | | 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', 'K'}, optional | 'C' means to flatten in row-major (C-style) order. | 'F' means to flatten in column-major (Fortran- | style) order. 'A' means to flatten in column-major | order if `a` is Fortran *contiguous* in memory, | row-major order otherwise. 'K' means to flatten | `a` in the order the elements occur in memory. | The default is 'C'. | | Returns | ------- | y : ndarray | A copy of the input array, flattened to one dimension. | | See Also | -------- | ravel : Return a flattened array. | flat : A 1-D flat iterator over the array. | | Examples | -------- | >>> a = np.array([[1,2], [3,4]]) | >>> a.flatten() | array([1, 2, 3, 4]) | >>> a.flatten('F') | array([1, 3, 2, 4]) | | getfield(...) | a.getfield(dtype, offset=0) | | Returns a field of the given array as a certain type. | | A field is a view of the array data with a given data-type. The values in | the view are determined by the given type and the offset into the current | array in bytes. The offset needs to be such that the view dtype fits in the | array dtype; for example an array of dtype complex128 has 16-byte elements. | If taking a view with a 32-bit integer (4 bytes), the offset needs to be | between 0 and 12 bytes. | | Parameters | ---------- | dtype : str or dtype | The data type of the view. The dtype size of the view can not be larger | than that of the array itself. | offset : int | Number of bytes to skip before beginning the element view. | | Examples | -------- | >>> x = np.diag([1.+1.j]*2) | >>> x[1, 1] = 2 + 4.j | >>> x | array([[1.+1.j, 0.+0.j], | [0.+0.j, 2.+4.j]]) | >>> x.getfield(np.float64) | array([[1., 0.], | [0., 2.]]) | | By choosing an offset of 8 bytes we can select the complex part of the | array for our view: | | >>> x.getfield(np.float64, offset=8) | array([[1., 0.], | [0., 4.]]) | | item(...) | a.item(*args) | | Copy an element of an array to a standard Python scalar and return it. | | Parameters | ---------- | \*args : Arguments (variable number and type) | | * none: in this case, the method only works for arrays | with one element (`a.size == 1`), which element is | copied into a standard Python scalar object and returned. | | * int_type: this argument is interpreted as a flat index into | the array, specifying which element to copy and return. | | * tuple of int_types: functions as does a single int_type argument, | except that the argument is interpreted as an nd-index into the | array. | | Returns | ------- | z : Standard Python scalar object | A copy of the specified element of the array as a suitable | Python scalar | | Notes | ----- | When the data type of `a` is longdouble or clongdouble, item() returns | a scalar array object because there is no available Python scalar that | would not lose information. Void arrays return a buffer object for item(), | unless fields are defined, in which case a tuple is returned. | | `item` is very similar to a[args], except, instead of an array scalar, | a standard Python scalar is returned. This can be useful for speeding up | access to elements of the array and doing arithmetic on elements of the | array using Python's optimized math. | | Examples | -------- | >>> np.random.seed(123) | >>> x = np.random.randint(9, size=(3, 3)) | >>> x | array([[2, 2, 6], | [1, 3, 6], | [1, 0, 1]]) | >>> x.item(3) | 1 | >>> x.item(7) | 0 | >>> x.item((0, 1)) | 2 | >>> x.item((2, 2)) | 1 | | 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 | -------- | >>> np.random.seed(123) | >>> x = np.random.randint(9, size=(3, 3)) | >>> x | array([[2, 2, 6], | [1, 3, 6], | [1, 0, 1]]) | >>> x.itemset(4, 0) | >>> x.itemset((2, 2), 9) | >>> x | array([[2, 2, 6], | [1, 0, 6], | [1, 0, 9]]) | | max(...) | a.max(axis=None, out=None, keepdims=False, initial=<no value>, where=True) | | Return the maximum along a given axis. | | Refer to `numpy.amax` for full documentation. | | See Also | -------- | numpy.amax : equivalent function | | mean(...) | a.mean(axis=None, dtype=None, out=None, keepdims=False) | | Returns the average of the array elements along given axis. | | Refer to `numpy.mean` for full documentation. | | See Also | -------- | numpy.mean : equivalent function | | min(...) | a.min(axis=None, out=None, keepdims=False, initial=<no value>, where=True) | | Return the minimum along a given axis. | | Refer to `numpy.amin` for full documentation. | | See Also | -------- | numpy.amin : equivalent function | | newbyteorder(...) | arr.newbyteorder(new_order='S') | | Return the array with the same data viewed with a different byte order. | | Equivalent to:: | | arr.view(arr.dtype.newbytorder(new_order)) | | Changes are also made in all fields and sub-arrays of the array data | type. | | | | Parameters | ---------- | new_order : string, optional | Byte order to force; a value from the byte order specifications | below. `new_order` codes can be any of: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_arr : array | New array object with the dtype reflecting given change to the | byte order. | | nonzero(...) | a.nonzero() | | Return the indices of the elements that are non-zero. | | Refer to `numpy.nonzero` for full documentation. | | See Also | -------- | numpy.nonzero : equivalent function | | partition(...) | a.partition(kth, axis=-1, kind='introselect', order=None) | | Rearranges the elements in the array in such a way that the value of the | element in kth position is in the position it would be in a sorted array. | All elements smaller than the kth element are moved before this element and | all equal or greater are moved behind it. The ordering of the elements in | the two partitions is undefined. | | .. versionadded:: 1.8.0 | | Parameters | ---------- | kth : int or sequence of ints | Element index to partition by. The kth element value will be in its | final sorted position and all smaller elements will be moved before it | and all equal or greater elements behind it. | The order of all elements in the partitions is undefined. | If provided with a sequence of kth it will partition all elements | indexed by kth of them into their sorted position at once. | axis : int, optional | Axis along which to sort. Default is -1, which means sort along the | last axis. | kind : {'introselect'}, optional | Selection algorithm. Default is 'introselect'. | order : str or list of str, optional | When `a` is an array with fields defined, this argument specifies | which fields to compare first, second, etc. A single field can | be specified as a string, and not all fields need to be specified, | but unspecified fields will still be used, in the order in which | they come up in the dtype, to break ties. | | See Also | -------- | numpy.partition : Return a parititioned copy of an array. | argpartition : Indirect partition. | sort : Full sort. | | Notes | ----- | See ``np.partition`` for notes on the different algorithms. | | Examples | -------- | >>> a = np.array([3, 4, 2, 1]) | >>> a.partition(3) | >>> a | array([2, 1, 3, 4]) | | >>> a.partition((1, 3)) | >>> a | array([1, 2, 3, 4]) | | prod(...) | a.prod(axis=None, dtype=None, out=None, keepdims=False, initial=1, where=True) | | 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, keepdims=False) | | 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 | | Notes | ----- | Unlike the free function `numpy.reshape`, this method on `ndarray` allows | the elements of the shape parameter to be passed in as separate arguments. | For example, ``a.reshape(10, 11)`` is equivalent to | ``a.reshape((10, 11))``. | | 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. | PyPy only: will always raise if the data memory must be changed, since | there is no reliable way to determine if references or views to it | exist. | | 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 references or is 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]], dtype=int32) | >>> x | array([[1.0e+000, 1.5e-323, 1.5e-323], | [1.5e-323, 1.0e+000, 1.5e-323], | [1.5e-323, 1.5e-323, 1.0e+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, (WRITEBACKIFCOPY 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 WRITEBACKIFCOPY and (deprecated) UPDATEIFCOPY flags 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 7 Boolean flags | in use, only four of which can be changed by the user: | WRITEBACKIFCOPY, 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) (deprecated), replaced by WRITEBACKIFCOPY; | | WRITEBACKIFCOPY (X) this array is a copy of some other array (referenced | by .base). When the C-API function PyArray_ResolveWritebackIfCopy is | called, the base array will be updated with the contents of this array. | | All flags can be accessed using the single (upper case) letter as well | as the full name. | | Examples | -------- | >>> y = np.array([[3, 1, 7], | ... [2, 0, 0], | ... [8, 5, 9]]) | >>> 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 | WRITEBACKIFCOPY : False | UPDATEIFCOPY : False | >>> y.setflags(write=0, align=0) | >>> y.flags | C_CONTIGUOUS : True | F_CONTIGUOUS : False | OWNDATA : True | WRITEABLE : False | ALIGNED : False | WRITEBACKIFCOPY : False | UPDATEIFCOPY : False | >>> y.setflags(uic=1) | Traceback (most recent call last): | File "<stdin>", line 1, in <module> | ValueError: cannot set WRITEBACKIFCOPY flag to True | | sort(...) | a.sort(axis=-1, kind=None, order=None) | | Sort an array in-place. Refer to `numpy.sort` for full documentation. | | Parameters | ---------- | axis : int, optional | Axis along which to sort. Default is -1, which means sort along the | last axis. | kind : {'quicksort', 'mergesort', 'heapsort', 'stable'}, optional | Sorting algorithm. The default is 'quicksort'. Note that both 'stable' | and 'mergesort' use timsort under the covers and, in general, the | actual implementation will vary with datatype. The 'mergesort' option | is retained for backwards compatibility. | | .. versionchanged:: 1.15.0. | The 'stable' option was added. | | order : str or list of str, optional | When `a` is an array with fields defined, this argument specifies | which fields to compare first, second, etc. A single field can | be specified as a string, and not all fields need be specified, | but unspecified fields will still be used, in the order in which | they come up in the dtype, to break ties. | | See Also | -------- | numpy.sort : Return a sorted copy of an array. | numpy.argsort : Indirect sort. | numpy.lexsort : Indirect stable sort on multiple keys. | numpy.searchsorted : Find elements in sorted array. | numpy.partition: Partial sort. | | Notes | ----- | See `numpy.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([(b'c', 1), (b'a', 2)], | dtype=[('x', 'S1'), ('y', '<i8')]) | | squeeze(...) | a.squeeze(axis=None) | | Remove single-dimensional entries from the shape of `a`. | | Refer to `numpy.squeeze` for full documentation. | | See Also | -------- | numpy.squeeze : equivalent function | | std(...) | a.std(axis=None, dtype=None, out=None, ddof=0, keepdims=False) | | Returns the standard deviation of the array elements along given axis. | | Refer to `numpy.std` for full documentation. | | See Also | -------- | numpy.std : equivalent function | | sum(...) | a.sum(axis=None, dtype=None, out=None, keepdims=False, initial=0, where=True) | | Return the sum of the array elements over the given axis. | | Refer to `numpy.sum` for full documentation. | | See Also | -------- | numpy.sum : equivalent function | | swapaxes(...) | a.swapaxes(axis1, axis2) | | Return a view of the array with `axis1` and `axis2` interchanged. | | Refer to `numpy.swapaxes` for full documentation. | | See Also | -------- | numpy.swapaxes : equivalent function | | take(...) | a.take(indices, axis=None, out=None, mode='raise') | | Return an array formed from the elements of `a` at the given indices. | | Refer to `numpy.take` for full documentation. | | See Also | -------- | numpy.take : equivalent function | | tobytes(...) | a.tobytes(order='C') | | Construct Python bytes containing the raw data bytes in the array. | | Constructs Python bytes showing a copy of the raw contents of | data memory. The bytes object can be produced in either 'C' or 'Fortran', | or 'Any' order (the default is 'C'-order). 'Any' order means C-order | unless the F_CONTIGUOUS flag in the array is set, in which case it | means 'Fortran' order. | | .. versionadded:: 1.9.0 | | Parameters | ---------- | order : {'C', 'F', None}, optional | Order of the data for multidimensional arrays: | C, Fortran, or the same as for the original array. | | Returns | ------- | s : bytes | Python bytes exhibiting a copy of `a`'s raw data. | | Examples | -------- | >>> x = np.array([[0, 1], [2, 3]], dtype='<u2') | >>> x.tobytes() | b'\x00\x00\x01\x00\x02\x00\x03\x00' | >>> x.tobytes('C') == x.tobytes() | True | >>> x.tobytes('F') | b'\x00\x00\x02\x00\x01\x00\x03\x00' | | tofile(...) | a.tofile(fid, sep="", format="%s") | | Write array to a file as text or binary (default). | | Data is always written in 'C' order, independent of the order of `a`. | The data produced by this method can be recovered using the function | fromfile(). | | Parameters | ---------- | fid : file or str or Path | An open file object, or a string containing a filename. | | .. versionchanged:: 1.17.0 | `pathlib.Path` objects are now accepted. | | sep : str | Separator between array items for text output. | If "" (empty), a binary file is written, equivalent to | ``file.write(a.tobytes())``. | format : str | Format string for text file output. | Each entry in the array is formatted to text by first converting | it to the closest Python type, and then using "format" % item. | | Notes | ----- | This is a convenience function for quick storage of array data. | Information on endianness and precision is lost, so this method is not a | good choice for files intended to archive data or transport data between | machines with different endianness. Some of these problems can be overcome | by outputting the data as text files, at the expense of speed and file | size. | | When fid is a file object, array contents are directly written to the | file, bypassing the file object's ``write`` method. As a result, tofile | cannot be used with files objects supporting compression (e.g., GzipFile) | or file-like objects that do not support ``fileno()`` (e.g., BytesIO). | | tolist(...) | a.tolist() | | Return the array as an ``a.ndim``-levels deep nested list of Python scalars. | | Return a copy of the array data as a (nested) Python list. | Data items are converted to the nearest compatible builtin Python type, via | the `~numpy.ndarray.item` function. | | If ``a.ndim`` is 0, then since the depth of the nested list is 0, it will | not be a list at all, but a simple Python scalar. | | Parameters | ---------- | none | | Returns | ------- | y : object, or list of object, or list of list of object, or ... | The possibly nested list of array elements. | | Notes | ----- | The array may be recreated via ``a = np.array(a.tolist())``, although this | may sometimes lose precision. | | Examples | -------- | For a 1D array, ``a.tolist()`` is almost the same as ``list(a)``, | except that ``tolist`` changes numpy scalars to Python scalars: | | >>> a = np.uint32([1, 2]) | >>> a_list = list(a) | >>> a_list | [1, 2] | >>> type(a_list[0]) | <class 'numpy.uint32'> | >>> a_tolist = a.tolist() | >>> a_tolist | [1, 2] | >>> type(a_tolist[0]) | <class 'int'> | | Additionally, for a 2D array, ``tolist`` applies recursively: | | >>> a = np.array([[1, 2], [3, 4]]) | >>> list(a) | [array([1, 2]), array([3, 4])] | >>> a.tolist() | [[1, 2], [3, 4]] | | The base case for this recursion is a 0D array: | | >>> a = np.array(1) | >>> list(a) | Traceback (most recent call last): | ... | TypeError: iteration over a 0-d array | >>> a.tolist() | 1 | | tostring(...) | a.tostring(order='C') | | A compatibility alias for `tobytes`, with exactly the same behavior. | | Despite its name, it returns `bytes` not `str`\ s. | | .. deprecated:: 1.19.0 | | 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, as a transposed vector is simply the | same vector. To convert a 1-D array into a 2D column vector, an additional | dimension must be added. `np.atleast2d(a).T` achieves this, as does | `a[:, np.newaxis]`. | For a 2-D array, this is a standard 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. | ndarray.reshape : Give a new shape to an array without changing its data. | | Examples | -------- | >>> a = np.array([[1, 2], [3, 4]]) | >>> a | array([[1, 2], | [3, 4]]) | >>> a.transpose() | array([[1, 3], | [2, 4]]) | >>> a.transpose((1, 0)) | array([[1, 3], | [2, 4]]) | >>> a.transpose(1, 0) | array([[1, 3], | [2, 4]]) | | var(...) | a.var(axis=None, dtype=None, out=None, ddof=0, keepdims=False) | | Returns the variance of the array elements, along given axis. | | Refer to `numpy.var` for full documentation. | | See Also | -------- | numpy.var : equivalent function | | view(...) | a.view([dtype][, type]) | | New view of array with the same data. | | .. note:: | Passing None for ``dtype`` is different from omitting the parameter, | since the former invokes ``dtype(None)`` which is an alias for | ``dtype('float_')``. | | Parameters | ---------- | dtype : data-type or ndarray sub-class, optional | Data-type descriptor of the returned view, e.g., float32 or int16. | Omitting it 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, omission | of the parameter 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.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 | >>> x | array([(1, 20), (3, 4)], dtype=[('a', 'i1'), ('b', 'i1')]) | | Using a view to convert an array to a recarray: | | >>> z = x.view(np.recarray) | >>> z.a | array([1, 3], 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): | ... | ValueError: To change to a dtype of a different size, the array must be C-contiguous | >>> z = y.copy() | >>> z.view(dtype=[('width', np.int16), ('length', np.int16)]) | array([[(1, 2)], | [(4, 5)]], dtype=[('width', '<i2'), ('length', '<i2')]) | | ---------------------------------------------------------------------- | Data descriptors inherited from ndarray: | | T | The transposed array. | | Same as ``self.transpose()``. | | 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.]) | | See Also | -------- | transpose | | __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): | | .. autoattribute:: numpy.core._internal._ctypes.data | :noindex: | | .. autoattribute:: numpy.core._internal._ctypes.shape | :noindex: | | .. autoattribute:: numpy.core._internal._ctypes.strides | :noindex: | | .. automethod:: numpy.core._internal._ctypes.data_as | :noindex: | | .. automethod:: numpy.core._internal._ctypes.shape_as | :noindex: | | .. automethod:: numpy.core._internal._ctypes.strides_as | :noindex: | | 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 = np.array([[0, 1], [2, 3]], dtype=np.int32) | >>> x | array([[0, 1], | [2, 3]], dtype=int32) | >>> x.ctypes.data | 31962608 # may vary | >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_uint32)) | <__main__.LP_c_uint object at 0x7ff2fc1fc200> # may vary | >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_uint32)).contents | c_uint(0) | >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_uint64)).contents | c_ulong(4294967296) | >>> x.ctypes.shape | <numpy.core._internal.c_long_Array_2 object at 0x7ff2fc1fce60> # may vary | >>> x.ctypes.strides | <numpy.core._internal.c_long_Array_2 object at 0x7ff2fc1ff320> # may vary | | 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. | WRITEBACKIFCOPY (X) | This array is a copy of some other array. The C-API function | PyArray_ResolveWritebackIfCopy must be called before deallocating | to the base array will be updated with the contents of this array. | UPDATEIFCOPY (U) | (Deprecated, use WRITEBACKIFCOPY) 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 WRITEBACKIFCOPY, 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``. | - WRITEBACKIFCOPY 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) | <class '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. | | The shape property is usually used to get the current shape of an array, | but may also be used to reshape the array in-place by assigning a tuple of | array dimensions to it. As with `numpy.reshape`, one of the new shape | dimensions can be -1, in which case its value is inferred from the size of | the array and the remaining dimensions. Reshaping an array in-place will | fail if a copy is required. | | 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 | >>> np.zeros((4,2))[::2].shape = (-1,) | Traceback (most recent call last): | File "<stdin>", line 1, in <module> | AttributeError: Incompatible shape for in-place modification. Use | `.reshape()` to make a copy with the desired shape. | | See Also | -------- | numpy.reshape : similar function | ndarray.reshape : similar method | | size | Number of elements in the array. | | Equal to ``np.prod(a.shape)``, i.e., the product of the array's | dimensions. | | Notes | ----- | `a.size` returns a standard arbitrary precision Python integer. This | may not be the case with other methods of obtaining the same value | (like the suggested ``np.prod(a.shape)``, which returns an instance | of ``np.int_``), and may be relevant if the value is used further in | calculations that may overflow a fixed size integer type. | | Examples | -------- | >>> x = np.zeros((3, 5, 2), dtype=np.complex128) | >>> x.size | 30 | >>> np.prod(x.shape) | 30 | | strides | Tuple of bytes to step in each dimension when traversing an array. | | The byte offset of element ``(i[0], i[1], ..., i[n])`` in an array `a` | is:: | | offset = sum(np.array(i) * a.strides) | | A more detailed explanation of strides can be found in the | "ndarray.rst" file in the NumPy reference guide. | | Notes | ----- | Imagine an array of 32-bit integers (each 4 bytes):: | | x = np.array([[0, 1, 2, 3, 4], | [5, 6, 7, 8, 9]], dtype=np.int32) | | This array is stored in memory as 40 bytes, one after the other | (known as a contiguous block of memory). The strides of an array tell | us how many bytes we have to skip in memory to move to the next position | along a certain axis. For example, we have to skip 4 bytes (1 value) to | move to the next column, but 20 bytes (5 values) to get to the same | position in the next row. As such, the strides for the array `x` will be | ``(20, 4)``. | | See Also | -------- | numpy.lib.stride_tricks.as_strided | | Examples | -------- | >>> y = np.reshape(np.arange(2*3*4), (2,3,4)) | >>> y | array([[[ 0, 1, 2, 3], | [ 4, 5, 6, 7], | [ 8, 9, 10, 11]], | [[12, 13, 14, 15], | [16, 17, 18, 19], | [20, 21, 22, 23]]]) | >>> y.strides | (48, 16, 4) | >>> y[1,1,1] | 17 | >>> offset=sum(y.strides * np.array((1,1,1))) | >>> offset/y.itemsize | 17 | | >>> x = np.reshape(np.arange(5*6*7*8), (5,6,7,8)).transpose(2,3,1,0) | >>> x.strides | (32, 4, 224, 1344) | >>> i = np.array([3,5,2,2]) | >>> offset = sum(i * x.strides) | >>> x[3,5,2,2] | 813 | >>> offset / x.itemsize | 813 | | ---------------------------------------------------------------------- | Data and other attributes inherited from ndarray: | | __hash__ = None class record(void) | A data-type scalar that allows field access as attribute lookup. | | Method resolution order: | record | void | flexible | generic | builtins.object | | Methods defined here: | | __getattribute__(self, attr) | Return getattr(self, name). | | __getitem__(self, indx) | Return self[key]. | | __repr__(self) | Return repr(self). | | __setattr__(self, attr, val) | Implement setattr(self, name, value). | | __str__(self) | Return str(self). | | pprint(self) | Pretty-print all fields. | | ---------------------------------------------------------------------- | Data descriptors defined here: | | __dict__ | dictionary for instance variables (if defined) | | __weakref__ | list of weak references to the object (if defined) | | ---------------------------------------------------------------------- | Methods inherited from void: | | __delitem__(self, key, /) | Delete self[key]. | | __eq__(self, value, /) | Return self==value. | | __ge__(self, value, /) | Return self>=value. | | __gt__(self, value, /) | Return self>value. | | __hash__(self, /) | Return hash(self). | | __le__(self, value, /) | Return self<=value. | | __len__(self, /) | Return len(self). | | __lt__(self, value, /) | Return self<value. | | __ne__(self, value, /) | Return self!=value. | | __setitem__(self, key, value, /) | Set self[key] to value. | | 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. | | 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. | | ---------------------------------------------------------------------- | Static methods inherited from void: | | __new__(*args, **kwargs) from builtins.type | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Data descriptors inherited from void: | | base | base object | | dtype | dtype object | | flags | integer value of flags | | ---------------------------------------------------------------------- | Methods inherited from generic: | | __abs__(self, /) | abs(self) | | __add__(self, value, /) | Return self+value. | | __and__(self, value, /) | Return self&value. | | __array__(...) | sc.__array__(dtype) return 0-dim array from scalar with specified dtype | | __array_wrap__(...) | sc.__array_wrap__(obj) return scalar from array | | __bool__(self, /) | self != 0 | | __copy__(...) | | __deepcopy__(...) | | __divmod__(self, value, /) | Return divmod(self, value). | | __float__(self, /) | float(self) | | __floordiv__(self, value, /) | Return self//value. | | __format__(...) | NumPy array scalar formatter | | __int__(self, /) | int(self) | | __invert__(self, /) | ~self | | __lshift__(self, value, /) | Return self<<value. | | __mod__(self, value, /) | Return self%value. | | __mul__(self, value, /) | Return self*value. | | __neg__(self, /) | -self | | __or__(self, value, /) | Return self|value. | | __pos__(self, /) | +self | | __pow__(self, value, mod=None, /) | Return pow(self, value, mod). | | __radd__(self, value, /) | Return value+self. | | __rand__(self, value, /) | Return value&self. | | __rdivmod__(self, value, /) | Return divmod(value, self). | | __reduce__(...) | Helper for pickle. | | __rfloordiv__(self, value, /) | Return value//self. | | __rlshift__(self, value, /) | Return value<<self. | | __rmod__(self, value, /) | Return value%self. | | __rmul__(self, value, /) | Return value*self. | | __ror__(self, value, /) | Return value|self. | | __rpow__(self, value, mod=None, /) | Return pow(value, self, mod). | | __rrshift__(self, value, /) | Return value>>self. | | __rshift__(self, value, /) | Return self>>value. | | __rsub__(self, value, /) | Return value-self. | | __rtruediv__(self, value, /) | Return value/self. | | __rxor__(self, value, /) | Return value^self. | | __setstate__(...) | | __sizeof__(...) | Size of object in memory, in bytes. | | __sub__(self, value, /) | Return self-value. | | __truediv__(self, value, /) | Return self/value. | | __xor__(self, value, /) | Return self^value. | | all(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | data | pointer to start of data | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension short = class int16(signedinteger) | Signed integer type, compatible with C ``short``. | Character code: ``'h'``. | Canonical name: ``np.short``. | Alias *on this platform*: ``np.int16``: 16-bit signed integer (-32768 to 32767). | | Method resolution order: | int16 | signedinteger | integer | number | generic | builtins.object | | Methods defined here: | | __abs__(self, /) | abs(self) | | __add__(self, value, /) | Return self+value. | | __and__(self, value, /) | Return self&value. | | __bool__(self, /) | self != 0 | | __divmod__(self, value, /) | Return divmod(self, value). | | __eq__(self, value, /) | Return self==value. | | __float__(self, /) | float(self) | | __floordiv__(self, value, /) | Return self//value. | | __ge__(self, value, /) | Return self>=value. | | __gt__(self, value, /) | Return self>value. | | __hash__(self, /) | Return hash(self). | | __index__(self, /) | Return self converted to an integer, if self is suitable for use as an index into a list. | | __int__(self, /) | int(self) | | __invert__(self, /) | ~self | | __le__(self, value, /) | Return self<=value. | | __lshift__(self, value, /) | Return self<<value. | | __lt__(self, value, /) | Return self<value. | | __mod__(self, value, /) | Return self%value. | | __mul__(self, value, /) | Return self*value. | | __ne__(self, value, /) | Return self!=value. | | __neg__(self, /) | -self | | __or__(self, value, /) | Return self|value. | | __pos__(self, /) | +self | | __pow__(self, value, mod=None, /) | Return pow(self, value, mod). | | __radd__(self, value, /) | Return value+self. | | __rand__(self, value, /) | Return value&self. | | __rdivmod__(self, value, /) | Return divmod(value, self). | | __repr__(self, /) | Return repr(self). | | __rfloordiv__(self, value, /) | Return value//self. | | __rlshift__(self, value, /) | Return value<<self. | | __rmod__(self, value, /) | Return value%self. | | __rmul__(self, value, /) | Return value*self. | | __ror__(self, value, /) | Return value|self. | | __rpow__(self, value, mod=None, /) | Return pow(value, self, mod). | | __rrshift__(self, value, /) | Return value>>self. | | __rshift__(self, value, /) | Return self>>value. | | __rsub__(self, value, /) | Return value-self. | | __rtruediv__(self, value, /) | Return value/self. | | __rxor__(self, value, /) | Return value^self. | | __str__(self, /) | Return str(self). | | __sub__(self, value, /) | Return self-value. | | __truediv__(self, value, /) | Return self/value. | | __xor__(self, value, /) | Return self^value. | | ---------------------------------------------------------------------- | Static methods defined here: | | __new__(*args, **kwargs) from builtins.type | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Methods inherited from integer: | | __round__(...) | | ---------------------------------------------------------------------- | Data descriptors inherited from integer: | | denominator | denominator of value (1) | | numerator | numerator of value (the value itself) | | ---------------------------------------------------------------------- | Methods inherited from generic: | | __array__(...) | sc.__array__(dtype) return 0-dim array from scalar with specified dtype | | __array_wrap__(...) | sc.__array_wrap__(obj) return scalar from array | | __copy__(...) | | __deepcopy__(...) | | __format__(...) | NumPy array scalar formatter | | __getitem__(self, key, /) | Return self[key]. | | __reduce__(...) | Helper for pickle. | | __setstate__(...) | | __sizeof__(...) | Size of object in memory, in bytes. | | all(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | getfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | base | base object | | data | pointer to start of data | | dtype | get array data-descriptor | | flags | integer value of flags | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension class signedinteger(integer) | Abstract base class of all signed integer scalar types. | | Method resolution order: | signedinteger | integer | number | generic | builtins.object | | Methods inherited from integer: | | __round__(...) | | ---------------------------------------------------------------------- | Data descriptors inherited from integer: | | denominator | denominator of value (1) | | numerator | numerator of value (the value itself) | | ---------------------------------------------------------------------- | Methods inherited from generic: | | __abs__(self, /) | abs(self) | | __add__(self, value, /) | Return self+value. | | __and__(self, value, /) | Return self&value. | | __array__(...) | sc.__array__(dtype) return 0-dim array from scalar with specified dtype | | __array_wrap__(...) | sc.__array_wrap__(obj) return scalar from array | | __bool__(self, /) | self != 0 | | __copy__(...) | | __deepcopy__(...) | | __divmod__(self, value, /) | Return divmod(self, value). | | __eq__(self, value, /) | Return self==value. | | __float__(self, /) | float(self) | | __floordiv__(self, value, /) | Return self//value. | | __format__(...) | NumPy array scalar formatter | | __ge__(self, value, /) | Return self>=value. | | __getitem__(self, key, /) | Return self[key]. | | __gt__(self, value, /) | Return self>value. | | __int__(self, /) | int(self) | | __invert__(self, /) | ~self | | __le__(self, value, /) | Return self<=value. | | __lshift__(self, value, /) | Return self<<value. | | __lt__(self, value, /) | Return self<value. | | __mod__(self, value, /) | Return self%value. | | __mul__(self, value, /) | Return self*value. | | __ne__(self, value, /) | Return self!=value. | | __neg__(self, /) | -self | | __or__(self, value, /) | Return self|value. | | __pos__(self, /) | +self | | __pow__(self, value, mod=None, /) | Return pow(self, value, mod). | | __radd__(self, value, /) | Return value+self. | | __rand__(self, value, /) | Return value&self. | | __rdivmod__(self, value, /) | Return divmod(value, self). | | __reduce__(...) | Helper for pickle. | | __rfloordiv__(self, value, /) | Return value//self. | | __rlshift__(self, value, /) | Return value<<self. | | __rmod__(self, value, /) | Return value%self. | | __rmul__(self, value, /) | Return value*self. | | __ror__(self, value, /) | Return value|self. | | __rpow__(self, value, mod=None, /) | Return pow(value, self, mod). | | __rrshift__(self, value, /) | Return value>>self. | | __rshift__(self, value, /) | Return self>>value. | | __rsub__(self, value, /) | Return value-self. | | __rtruediv__(self, value, /) | Return value/self. | | __rxor__(self, value, /) | Return value^self. | | __setstate__(...) | | __sizeof__(...) | Size of object in memory, in bytes. | | __sub__(self, value, /) | Return self-value. | | __truediv__(self, value, /) | Return self/value. | | __xor__(self, value, /) | Return self^value. | | all(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | getfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | base | base object | | data | pointer to start of data | | dtype | get array data-descriptor | | flags | integer value of flags | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension | | ---------------------------------------------------------------------- | Data and other attributes inherited from generic: | | __hash__ = None single = class float32(floating) | Single-precision floating-point number type, compatible with C ``float``. | Character code: ``'f'``. | Canonical name: ``np.single``. | Alias *on this platform*: ``np.float32``: 32-bit-precision floating-point number type: sign bit, 8 bits exponent, 23 bits mantissa. | | Method resolution order: | float32 | floating | inexact | number | generic | builtins.object | | Methods defined here: | | __abs__(self, /) | abs(self) | | __add__(self, value, /) | Return self+value. | | __bool__(self, /) | self != 0 | | __divmod__(self, value, /) | Return divmod(self, value). | | __eq__(self, value, /) | Return self==value. | | __float__(self, /) | float(self) | | __floordiv__(self, value, /) | Return self//value. | | __ge__(self, value, /) | Return self>=value. | | __gt__(self, value, /) | Return self>value. | | __hash__(self, /) | Return hash(self). | | __int__(self, /) | int(self) | | __le__(self, value, /) | Return self<=value. | | __lt__(self, value, /) | Return self<value. | | __mod__(self, value, /) | Return self%value. | | __mul__(self, value, /) | Return self*value. | | __ne__(self, value, /) | Return self!=value. | | __neg__(self, /) | -self | | __pos__(self, /) | +self | | __pow__(self, value, mod=None, /) | Return pow(self, value, mod). | | __radd__(self, value, /) | Return value+self. | | __rdivmod__(self, value, /) | Return divmod(value, self). | | __repr__(self, /) | Return repr(self). | | __rfloordiv__(self, value, /) | Return value//self. | | __rmod__(self, value, /) | Return value%self. | | __rmul__(self, value, /) | Return value*self. | | __rpow__(self, value, mod=None, /) | Return pow(value, self, mod). | | __rsub__(self, value, /) | Return value-self. | | __rtruediv__(self, value, /) | Return value/self. | | __str__(self, /) | Return str(self). | | __sub__(self, value, /) | Return self-value. | | __truediv__(self, value, /) | Return self/value. | | as_integer_ratio(...) | single.as_integer_ratio() -> (int, int) | | Return a pair of integers, whose ratio is exactly equal to the original | floating point number, and with a positive denominator. | Raise OverflowError on infinities and a ValueError on NaNs. | | >>> np.single(10.0).as_integer_ratio() | (10, 1) | >>> np.single(0.0).as_integer_ratio() | (0, 1) | >>> np.single(-.25).as_integer_ratio() | (-1, 4) | | ---------------------------------------------------------------------- | Static methods defined here: | | __new__(*args, **kwargs) from builtins.type | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Methods inherited from floating: | | __round__(...) | | ---------------------------------------------------------------------- | Methods inherited from generic: | | __and__(self, value, /) | Return self&value. | | __array__(...) | sc.__array__(dtype) return 0-dim array from scalar with specified dtype | | __array_wrap__(...) | sc.__array_wrap__(obj) return scalar from array | | __copy__(...) | | __deepcopy__(...) | | __format__(...) | NumPy array scalar formatter | | __getitem__(self, key, /) | Return self[key]. | | __invert__(self, /) | ~self | | __lshift__(self, value, /) | Return self<<value. | | __or__(self, value, /) | Return self|value. | | __rand__(self, value, /) | Return value&self. | | __reduce__(...) | Helper for pickle. | | __rlshift__(self, value, /) | Return value<<self. | | __ror__(self, value, /) | Return value|self. | | __rrshift__(self, value, /) | Return value>>self. | | __rshift__(self, value, /) | Return self>>value. | | __rxor__(self, value, /) | Return value^self. | | __setstate__(...) | | __sizeof__(...) | Size of object in memory, in bytes. | | __xor__(self, value, /) | Return self^value. | | all(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | getfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | base | base object | | data | pointer to start of data | | dtype | get array data-descriptor | | flags | integer value of flags | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension singlecomplex = class complex64(complexfloating) | Complex number type composed of two single-precision floating-point | numbers. | Character code: ``'F'``. | Canonical name: ``np.csingle``. | Alias: ``np.singlecomplex``. | Alias *on this platform*: ``np.complex64``: Complex number type composed of 2 32-bit-precision floating-point numbers. | | Method resolution order: | complex64 | complexfloating | inexact | number | generic | builtins.object | | Methods defined here: | | __abs__(self, /) | abs(self) | | __add__(self, value, /) | Return self+value. | | __bool__(self, /) | self != 0 | | __complex__(...) | | __eq__(self, value, /) | Return self==value. | | __float__(self, /) | float(self) | | __floordiv__(self, value, /) | Return self//value. | | __ge__(self, value, /) | Return self>=value. | | __gt__(self, value, /) | Return self>value. | | __hash__(self, /) | Return hash(self). | | __int__(self, /) | int(self) | | __le__(self, value, /) | Return self<=value. | | __lt__(self, value, /) | Return self<value. | | __mul__(self, value, /) | Return self*value. | | __ne__(self, value, /) | Return self!=value. | | __neg__(self, /) | -self | | __pos__(self, /) | +self | | __pow__(self, value, mod=None, /) | Return pow(self, value, mod). | | __radd__(self, value, /) | Return value+self. | | __repr__(self, /) | Return repr(self). | | __rfloordiv__(self, value, /) | Return value//self. | | __rmul__(self, value, /) | Return value*self. | | __rpow__(self, value, mod=None, /) | Return pow(value, self, mod). | | __rsub__(self, value, /) | Return value-self. | | __rtruediv__(self, value, /) | Return value/self. | | __str__(self, /) | Return str(self). | | __sub__(self, value, /) | Return self-value. | | __truediv__(self, value, /) | Return self/value. | | ---------------------------------------------------------------------- | Static methods defined here: | | __new__(*args, **kwargs) from builtins.type | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Methods inherited from complexfloating: | | __round__(...) | | ---------------------------------------------------------------------- | Methods inherited from generic: | | __and__(self, value, /) | Return self&value. | | __array__(...) | sc.__array__(dtype) return 0-dim array from scalar with specified dtype | | __array_wrap__(...) | sc.__array_wrap__(obj) return scalar from array | | __copy__(...) | | __deepcopy__(...) | | __divmod__(self, value, /) | Return divmod(self, value). | | __format__(...) | NumPy array scalar formatter | | __getitem__(self, key, /) | Return self[key]. | | __invert__(self, /) | ~self | | __lshift__(self, value, /) | Return self<<value. | | __mod__(self, value, /) | Return self%value. | | __or__(self, value, /) | Return self|value. | | __rand__(self, value, /) | Return value&self. | | __rdivmod__(self, value, /) | Return divmod(value, self). | | __reduce__(...) | Helper for pickle. | | __rlshift__(self, value, /) | Return value<<self. | | __rmod__(self, value, /) | Return value%self. | | __ror__(self, value, /) | Return value|self. | | __rrshift__(self, value, /) | Return value>>self. | | __rshift__(self, value, /) | Return self>>value. | | __rxor__(self, value, /) | Return value^self. | | __setstate__(...) | | __sizeof__(...) | Size of object in memory, in bytes. | | __xor__(self, value, /) | Return self^value. | | all(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | getfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | base | base object | | data | pointer to start of data | | dtype | get array data-descriptor | | flags | integer value of flags | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension str0 = class str_(builtins.str, character) | str(object='') -> str | str(bytes_or_buffer[, encoding[, errors]]) -> str | | Create a new string object from the given object. If encoding or | errors is specified, then the object must expose a data buffer | that will be decoded using the given encoding and error handler. | Otherwise, returns the result of object.__str__() (if defined) | or repr(object). | encoding defaults to sys.getdefaultencoding(). | errors defaults to 'strict'. | | Method resolution order: | str_ | builtins.str | character | flexible | generic | builtins.object | | Methods defined here: | | __eq__(self, value, /) | Return self==value. | | __ge__(self, value, /) | Return self>=value. | | __gt__(self, value, /) | Return self>value. | | __hash__(self, /) | Return hash(self). | | __le__(self, value, /) | Return self<=value. | | __lt__(self, value, /) | Return self<value. | | __ne__(self, value, /) | Return self!=value. | | __repr__(self, /) | Return repr(self). | | __str__(self, /) | Return str(self). | | ---------------------------------------------------------------------- | Static methods defined here: | | __new__(*args, **kwargs) from builtins.type | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Methods inherited from builtins.str: | | __add__(self, value, /) | Return self+value. | | __contains__(self, key, /) | Return key in self. | | __format__(self, format_spec, /) | Return a formatted version of the string as described by format_spec. | | __getattribute__(self, name, /) | Return getattr(self, name). | | __getitem__(self, key, /) | Return self[key]. | | __getnewargs__(...) | | __iter__(self, /) | Implement iter(self). | | __len__(self, /) | Return len(self). | | __mod__(self, value, /) | Return self%value. | | __mul__(self, value, /) | Return self*value. | | __rmod__(self, value, /) | Return value%self. | | __rmul__(self, value, /) | Return value*self. | | __sizeof__(self, /) | Return the size of the string in memory, in bytes. | | capitalize(self, /) | Return a capitalized version of the string. | | More specifically, make the first character have upper case and the rest lower | case. | | casefold(self, /) | Return a version of the string suitable for caseless comparisons. | | center(self, width, fillchar=' ', /) | Return a centered 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. | | encode(self, /, encoding='utf-8', errors='strict') | Encode the string using the codec registered for encoding. | | encoding | The encoding in which to encode the string. | errors | The error handling scheme to use for encoding errors. | The default is 'strict' meaning that encoding errors raise a | UnicodeEncodeError. Other possible values are 'ignore', 'replace' and | 'xmlcharrefreplace' as well as any other name registered with | codecs.register_error that can handle UnicodeEncodeErrors. | | endswith(...) | S.endswith(suffix[, start[, end]]) -> bool | | Return True if S ends with the specified suffix, False otherwise. | With optional start, test S beginning at that position. | With optional end, stop comparing S at that position. | suffix can also be a tuple of strings to try. | | expandtabs(self, /, tabsize=8) | Return a copy 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) -> str | | Return a formatted version of S, using substitutions from args and kwargs. | The substitutions are identified by braces ('{' and '}'). | | format_map(...) | S.format_map(mapping) -> str | | Return a formatted version of S, using substitutions from mapping. | The substitutions are identified by braces ('{' and '}'). | | index(...) | S.index(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. | | Raises ValueError when the substring is not found. | | isalnum(self, /) | Return True if the string is an alpha-numeric string, False otherwise. | | A string is alpha-numeric if all characters in the string are alpha-numeric and | there is at least one character in the string. | | isalpha(self, /) | Return True if the string is an alphabetic string, False otherwise. | | A string is alphabetic if all characters in the string are alphabetic and there | is at least one character in the string. | | isascii(self, /) | Return True if all characters in the string are ASCII, False otherwise. | | ASCII characters have code points in the range U+0000-U+007F. | Empty string is ASCII too. | | isdecimal(self, /) | Return True if the string is a decimal string, False otherwise. | | A string is a decimal string if all characters in the string are decimal and | there is at least one character in the string. | | isdigit(self, /) | Return True if the string is a digit string, False otherwise. | | A string is a digit string if all characters in the string are digits and there | is at least one character in the string. | | isidentifier(self, /) | Return True if the string is a valid Python identifier, False otherwise. | | Call keyword.iskeyword(s) to test whether string s is a reserved identifier, | such as "def" or "class". | | islower(self, /) | Return True if the string is a lowercase string, False otherwise. | | A string is lowercase if all cased characters in the string are lowercase and | there is at least one cased character in the string. | | isnumeric(self, /) | Return True if the string is a numeric string, False otherwise. | | A string is numeric if all characters in the string are numeric and there is at | least one character in the string. | | isprintable(self, /) | Return True if the string is printable, False otherwise. | | A string is printable if all of its characters are considered printable in | repr() or if it is empty. | | isspace(self, /) | Return True if the string is a whitespace string, False otherwise. | | A string is whitespace if all characters in the string are whitespace and there | is at least one character in the string. | | istitle(self, /) | Return True if the string is a title-cased string, False otherwise. | | In a title-cased string, upper- and title-case characters may only | follow uncased characters and lowercase characters only cased ones. | | isupper(self, /) | Return True if the string is an uppercase string, False otherwise. | | A string is uppercase if all cased characters in the string are uppercase and | there is at least one cased character in the string. | | join(self, iterable, /) | Concatenate any number of strings. | | The string whose method is called is inserted in between each given string. | The result is returned as a new string. | | Example: '.'.join(['ab', 'pq', 'rs']) -> 'ab.pq.rs' | | ljust(self, width, fillchar=' ', /) | Return a left-justified string of length width. | | Padding is done using the specified fill character (default is a space). | | lower(self, /) | Return a copy of the string converted to lowercase. | | lstrip(self, chars=None, /) | Return a copy of the string with leading whitespace removed. | | If chars is given and not None, remove characters in chars instead. | | partition(self, sep, /) | Partition the string into three parts using the given separator. | | This will search for the separator in the string. If the separator is found, | returns a 3-tuple containing the part before the separator, the separator | itself, and the part after it. | | If the separator is not found, returns a 3-tuple containing the original string | and two empty strings. | | replace(self, old, new, count=-1, /) | Return a copy with all occurrences of substring old replaced by new. | | count | Maximum number of occurrences to replace. | -1 (the default value) means replace all occurrences. | | 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 | | 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. | | Raises ValueError when the substring is not found. | | rjust(self, width, fillchar=' ', /) | Return a right-justified string of length width. | | Padding is done using the specified fill character (default is a space). | | rpartition(self, sep, /) | Partition the string into three parts using the given separator. | | This will search for the separator in the string, starting at the end. If | the separator is found, returns a 3-tuple containing the part before the | separator, the separator itself, and the part after it. | | If the separator is not found, returns a 3-tuple containing two empty strings | and the original string. | | rsplit(self, /, sep=None, maxsplit=-1) | Return a list of the words in the string, using sep as the delimiter string. | | sep | The delimiter according which to split the string. | None (the default value) means split according to any whitespace, | and discard empty strings from the result. | maxsplit | Maximum number of splits to do. | -1 (the default value) means no limit. | | Splits are done starting at the end of the string and working to the front. | | rstrip(self, chars=None, /) | Return a copy of the string with trailing whitespace removed. | | If chars is given and not None, remove characters in chars instead. | | split(self, /, sep=None, maxsplit=-1) | Return a list of the words in the string, using sep as the delimiter string. | | sep | The delimiter according which to split the string. | None (the default value) means split according to any whitespace, | and discard empty strings from the result. | maxsplit | Maximum number of splits to do. | -1 (the default value) means no limit. | | splitlines(self, /, keepends=False) | Return a list of the lines in the string, 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(self, chars=None, /) | Return a copy of the string with leading and trailing whitespace removed. | | If chars is given and not None, remove characters in chars instead. | | swapcase(self, /) | Convert uppercase characters to lowercase and lowercase characters to uppercase. | | title(self, /) | Return a version of the string where each word is titlecased. | | More specifically, words start with uppercased characters and all remaining | cased characters have lower case. | | translate(self, table, /) | Replace each character in the string using the given translation table. | | table | Translation table, which must be a mapping of Unicode ordinals to | Unicode ordinals, strings, or None. | | The table must implement lookup/indexing via __getitem__, for instance a | dictionary or list. If this operation raises LookupError, the character is | left untouched. Characters mapped to None are deleted. | | upper(self, /) | Return a copy of the string converted to uppercase. | | zfill(self, width, /) | Pad a numeric string with zeros on the left, to fill a field of the given width. | | The string is never truncated. | | ---------------------------------------------------------------------- | Static methods inherited from builtins.str: | | maketrans(...) | Return a translation table usable for str.translate(). | | If there is only one argument, it must be a dictionary mapping Unicode | ordinals (integers) or characters to Unicode ordinals, strings or None. | Character keys will be then converted to ordinals. | If there are two arguments, they must be strings of equal length, and | in the resulting dictionary, each character in x will be mapped to the | character at the same position in y. If there is a third argument, it | must be a string, whose characters will be mapped to None in the result. | | ---------------------------------------------------------------------- | Methods inherited from generic: | | __abs__(self, /) | abs(self) | | __and__(self, value, /) | Return self&value. | | __array__(...) | sc.__array__(dtype) return 0-dim array from scalar with specified dtype | | __array_wrap__(...) | sc.__array_wrap__(obj) return scalar from array | | __bool__(self, /) | self != 0 | | __copy__(...) | | __deepcopy__(...) | | __divmod__(self, value, /) | Return divmod(self, value). | | __float__(self, /) | float(self) | | __floordiv__(self, value, /) | Return self//value. | | __int__(self, /) | int(self) | | __invert__(self, /) | ~self | | __lshift__(self, value, /) | Return self<<value. | | __neg__(self, /) | -self | | __or__(self, value, /) | Return self|value. | | __pos__(self, /) | +self | | __pow__(self, value, mod=None, /) | Return pow(self, value, mod). | | __radd__(self, value, /) | Return value+self. | | __rand__(self, value, /) | Return value&self. | | __rdivmod__(self, value, /) | Return divmod(value, self). | | __reduce__(...) | Helper for pickle. | | __rfloordiv__(self, value, /) | Return value//self. | | __rlshift__(self, value, /) | Return value<<self. | | __ror__(self, value, /) | Return value|self. | | __rpow__(self, value, mod=None, /) | Return pow(value, self, mod). | | __rrshift__(self, value, /) | Return value>>self. | | __rshift__(self, value, /) | Return self>>value. | | __rsub__(self, value, /) | Return value-self. | | __rtruediv__(self, value, /) | Return value/self. | | __rxor__(self, value, /) | Return value^self. | | __setstate__(...) | | __sub__(self, value, /) | Return self-value. | | __truediv__(self, value, /) | Return self/value. | | __xor__(self, value, /) | Return self^value. | | all(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | getfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | base | base object | | data | pointer to start of data | | dtype | get array data-descriptor | | flags | integer value of flags | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension class str_(builtins.str, character) | str(object='') -> str | str(bytes_or_buffer[, encoding[, errors]]) -> str | | Create a new string object from the given object. If encoding or | errors is specified, then the object must expose a data buffer | that will be decoded using the given encoding and error handler. | Otherwise, returns the result of object.__str__() (if defined) | or repr(object). | encoding defaults to sys.getdefaultencoding(). | errors defaults to 'strict'. | | Method resolution order: | str_ | builtins.str | character | flexible | generic | builtins.object | | Methods defined here: | | __eq__(self, value, /) | Return self==value. | | __ge__(self, value, /) | Return self>=value. | | __gt__(self, value, /) | Return self>value. | | __hash__(self, /) | Return hash(self). | | __le__(self, value, /) | Return self<=value. | | __lt__(self, value, /) | Return self<value. | | __ne__(self, value, /) | Return self!=value. | | __repr__(self, /) | Return repr(self). | | __str__(self, /) | Return str(self). | | ---------------------------------------------------------------------- | Static methods defined here: | | __new__(*args, **kwargs) from builtins.type | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Methods inherited from builtins.str: | | __add__(self, value, /) | Return self+value. | | __contains__(self, key, /) | Return key in self. | | __format__(self, format_spec, /) | Return a formatted version of the string as described by format_spec. | | __getattribute__(self, name, /) | Return getattr(self, name). | | __getitem__(self, key, /) | Return self[key]. | | __getnewargs__(...) | | __iter__(self, /) | Implement iter(self). | | __len__(self, /) | Return len(self). | | __mod__(self, value, /) | Return self%value. | | __mul__(self, value, /) | Return self*value. | | __rmod__(self, value, /) | Return value%self. | | __rmul__(self, value, /) | Return value*self. | | __sizeof__(self, /) | Return the size of the string in memory, in bytes. | | capitalize(self, /) | Return a capitalized version of the string. | | More specifically, make the first character have upper case and the rest lower | case. | | casefold(self, /) | Return a version of the string suitable for caseless comparisons. | | center(self, width, fillchar=' ', /) | Return a centered 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. | | encode(self, /, encoding='utf-8', errors='strict') | Encode the string using the codec registered for encoding. | | encoding | The encoding in which to encode the string. | errors | The error handling scheme to use for encoding errors. | The default is 'strict' meaning that encoding errors raise a | UnicodeEncodeError. Other possible values are 'ignore', 'replace' and | 'xmlcharrefreplace' as well as any other name registered with | codecs.register_error that can handle UnicodeEncodeErrors. | | endswith(...) | S.endswith(suffix[, start[, end]]) -> bool | | Return True if S ends with the specified suffix, False otherwise. | With optional start, test S beginning at that position. | With optional end, stop comparing S at that position. | suffix can also be a tuple of strings to try. | | expandtabs(self, /, tabsize=8) | Return a copy 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) -> str | | Return a formatted version of S, using substitutions from args and kwargs. | The substitutions are identified by braces ('{' and '}'). | | format_map(...) | S.format_map(mapping) -> str | | Return a formatted version of S, using substitutions from mapping. | The substitutions are identified by braces ('{' and '}'). | | index(...) | S.index(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. | | Raises ValueError when the substring is not found. | | isalnum(self, /) | Return True if the string is an alpha-numeric string, False otherwise. | | A string is alpha-numeric if all characters in the string are alpha-numeric and | there is at least one character in the string. | | isalpha(self, /) | Return True if the string is an alphabetic string, False otherwise. | | A string is alphabetic if all characters in the string are alphabetic and there | is at least one character in the string. | | isascii(self, /) | Return True if all characters in the string are ASCII, False otherwise. | | ASCII characters have code points in the range U+0000-U+007F. | Empty string is ASCII too. | | isdecimal(self, /) | Return True if the string is a decimal string, False otherwise. | | A string is a decimal string if all characters in the string are decimal and | there is at least one character in the string. | | isdigit(self, /) | Return True if the string is a digit string, False otherwise. | | A string is a digit string if all characters in the string are digits and there | is at least one character in the string. | | isidentifier(self, /) | Return True if the string is a valid Python identifier, False otherwise. | | Call keyword.iskeyword(s) to test whether string s is a reserved identifier, | such as "def" or "class". | | islower(self, /) | Return True if the string is a lowercase string, False otherwise. | | A string is lowercase if all cased characters in the string are lowercase and | there is at least one cased character in the string. | | isnumeric(self, /) | Return True if the string is a numeric string, False otherwise. | | A string is numeric if all characters in the string are numeric and there is at | least one character in the string. | | isprintable(self, /) | Return True if the string is printable, False otherwise. | | A string is printable if all of its characters are considered printable in | repr() or if it is empty. | | isspace(self, /) | Return True if the string is a whitespace string, False otherwise. | | A string is whitespace if all characters in the string are whitespace and there | is at least one character in the string. | | istitle(self, /) | Return True if the string is a title-cased string, False otherwise. | | In a title-cased string, upper- and title-case characters may only | follow uncased characters and lowercase characters only cased ones. | | isupper(self, /) | Return True if the string is an uppercase string, False otherwise. | | A string is uppercase if all cased characters in the string are uppercase and | there is at least one cased character in the string. | | join(self, iterable, /) | Concatenate any number of strings. | | The string whose method is called is inserted in between each given string. | The result is returned as a new string. | | Example: '.'.join(['ab', 'pq', 'rs']) -> 'ab.pq.rs' | | ljust(self, width, fillchar=' ', /) | Return a left-justified string of length width. | | Padding is done using the specified fill character (default is a space). | | lower(self, /) | Return a copy of the string converted to lowercase. | | lstrip(self, chars=None, /) | Return a copy of the string with leading whitespace removed. | | If chars is given and not None, remove characters in chars instead. | | partition(self, sep, /) | Partition the string into three parts using the given separator. | | This will search for the separator in the string. If the separator is found, | returns a 3-tuple containing the part before the separator, the separator | itself, and the part after it. | | If the separator is not found, returns a 3-tuple containing the original string | and two empty strings. | | replace(self, old, new, count=-1, /) | Return a copy with all occurrences of substring old replaced by new. | | count | Maximum number of occurrences to replace. | -1 (the default value) means replace all occurrences. | | 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 | | 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. | | Raises ValueError when the substring is not found. | | rjust(self, width, fillchar=' ', /) | Return a right-justified string of length width. | | Padding is done using the specified fill character (default is a space). | | rpartition(self, sep, /) | Partition the string into three parts using the given separator. | | This will search for the separator in the string, starting at the end. If | the separator is found, returns a 3-tuple containing the part before the | separator, the separator itself, and the part after it. | | If the separator is not found, returns a 3-tuple containing two empty strings | and the original string. | | rsplit(self, /, sep=None, maxsplit=-1) | Return a list of the words in the string, using sep as the delimiter string. | | sep | The delimiter according which to split the string. | None (the default value) means split according to any whitespace, | and discard empty strings from the result. | maxsplit | Maximum number of splits to do. | -1 (the default value) means no limit. | | Splits are done starting at the end of the string and working to the front. | | rstrip(self, chars=None, /) | Return a copy of the string with trailing whitespace removed. | | If chars is given and not None, remove characters in chars instead. | | split(self, /, sep=None, maxsplit=-1) | Return a list of the words in the string, using sep as the delimiter string. | | sep | The delimiter according which to split the string. | None (the default value) means split according to any whitespace, | and discard empty strings from the result. | maxsplit | Maximum number of splits to do. | -1 (the default value) means no limit. | | splitlines(self, /, keepends=False) | Return a list of the lines in the string, 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(self, chars=None, /) | Return a copy of the string with leading and trailing whitespace removed. | | If chars is given and not None, remove characters in chars instead. | | swapcase(self, /) | Convert uppercase characters to lowercase and lowercase characters to uppercase. | | title(self, /) | Return a version of the string where each word is titlecased. | | More specifically, words start with uppercased characters and all remaining | cased characters have lower case. | | translate(self, table, /) | Replace each character in the string using the given translation table. | | table | Translation table, which must be a mapping of Unicode ordinals to | Unicode ordinals, strings, or None. | | The table must implement lookup/indexing via __getitem__, for instance a | dictionary or list. If this operation raises LookupError, the character is | left untouched. Characters mapped to None are deleted. | | upper(self, /) | Return a copy of the string converted to uppercase. | | zfill(self, width, /) | Pad a numeric string with zeros on the left, to fill a field of the given width. | | The string is never truncated. | | ---------------------------------------------------------------------- | Static methods inherited from builtins.str: | | maketrans(...) | Return a translation table usable for str.translate(). | | If there is only one argument, it must be a dictionary mapping Unicode | ordinals (integers) or characters to Unicode ordinals, strings or None. | Character keys will be then converted to ordinals. | If there are two arguments, they must be strings of equal length, and | in the resulting dictionary, each character in x will be mapped to the | character at the same position in y. If there is a third argument, it | must be a string, whose characters will be mapped to None in the result. | | ---------------------------------------------------------------------- | Methods inherited from generic: | | __abs__(self, /) | abs(self) | | __and__(self, value, /) | Return self&value. | | __array__(...) | sc.__array__(dtype) return 0-dim array from scalar with specified dtype | | __array_wrap__(...) | sc.__array_wrap__(obj) return scalar from array | | __bool__(self, /) | self != 0 | | __copy__(...) | | __deepcopy__(...) | | __divmod__(self, value, /) | Return divmod(self, value). | | __float__(self, /) | float(self) | | __floordiv__(self, value, /) | Return self//value. | | __int__(self, /) | int(self) | | __invert__(self, /) | ~self | | __lshift__(self, value, /) | Return self<<value. | | __neg__(self, /) | -self | | __or__(self, value, /) | Return self|value. | | __pos__(self, /) | +self | | __pow__(self, value, mod=None, /) | Return pow(self, value, mod). | | __radd__(self, value, /) | Return value+self. | | __rand__(self, value, /) | Return value&self. | | __rdivmod__(self, value, /) | Return divmod(value, self). | | __reduce__(...) | Helper for pickle. | | __rfloordiv__(self, value, /) | Return value//self. | | __rlshift__(self, value, /) | Return value<<self. | | __ror__(self, value, /) | Return value|self. | | __rpow__(self, value, mod=None, /) | Return pow(value, self, mod). | | __rrshift__(self, value, /) | Return value>>self. | | __rshift__(self, value, /) | Return self>>value. | | __rsub__(self, value, /) | Return value-self. | | __rtruediv__(self, value, /) | Return value/self. | | __rxor__(self, value, /) | Return value^self. | | __setstate__(...) | | __sub__(self, value, /) | Return self-value. | | __truediv__(self, value, /) | Return self/value. | | __xor__(self, value, /) | Return self^value. | | all(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | getfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | base | base object | | data | pointer to start of data | | dtype | get array data-descriptor | | flags | integer value of flags | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension string_ = class bytes_(builtins.bytes, character) | bytes(iterable_of_ints) -> bytes | bytes(string, encoding[, errors]) -> bytes | bytes(bytes_or_buffer) -> immutable copy of bytes_or_buffer | bytes(int) -> bytes object of size given by the parameter initialized with null bytes | bytes() -> empty bytes object | | Construct an immutable array of bytes from: | - an iterable yielding integers in range(256) | - a text string encoded using the specified encoding | - any object implementing the buffer API. | - an integer | | Method resolution order: | bytes_ | builtins.bytes | character | flexible | generic | builtins.object | | Methods defined here: | | __eq__(self, value, /) | Return self==value. | | __ge__(self, value, /) | Return self>=value. | | __gt__(self, value, /) | Return self>value. | | __hash__(self, /) | Return hash(self). | | __le__(self, value, /) | Return self<=value. | | __lt__(self, value, /) | Return self<value. | | __ne__(self, value, /) | Return self!=value. | | __repr__(self, /) | Return repr(self). | | __str__(self, /) | Return str(self). | | ---------------------------------------------------------------------- | Static methods defined here: | | __new__(*args, **kwargs) from builtins.type | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Methods inherited from builtins.bytes: | | __add__(self, value, /) | Return self+value. | | __contains__(self, key, /) | Return key in self. | | __getattribute__(self, name, /) | Return getattr(self, name). | | __getitem__(self, key, /) | Return self[key]. | | __getnewargs__(...) | | __iter__(self, /) | Implement iter(self). | | __len__(self, /) | Return len(self). | | __mod__(self, value, /) | Return self%value. | | __mul__(self, value, /) | Return self*value. | | __rmod__(self, value, /) | Return value%self. | | __rmul__(self, value, /) | Return value*self. | | capitalize(...) | B.capitalize() -> copy of B | | Return a copy of B with only its first character capitalized (ASCII) | and the rest lower-cased. | | center(self, width, fillchar=b' ', /) | Return a centered string of length width. | | Padding is done using the specified fill character. | | count(...) | B.count(sub[, start[, end]]) -> int | | Return the number of non-overlapping occurrences of subsection sub in | bytes B[start:end]. Optional arguments start and end are interpreted | as in slice notation. | | decode(self, /, encoding='utf-8', errors='strict') | Decode the bytes using the codec registered for encoding. | | encoding | The encoding with which to decode the bytes. | errors | The error handling scheme to use for the handling of decoding errors. | The default is 'strict' meaning that decoding errors raise a | UnicodeDecodeError. Other possible values are 'ignore' and 'replace' | as well as any other name registered with codecs.register_error that | can handle UnicodeDecodeErrors. | | endswith(...) | B.endswith(suffix[, start[, end]]) -> bool | | Return True if B ends with the specified suffix, False otherwise. | With optional start, test B beginning at that position. | With optional end, stop comparing B at that position. | suffix can also be a tuple of bytes to try. | | expandtabs(self, /, tabsize=8) | Return a copy where all tab characters are expanded using spaces. | | If tabsize is not given, a tab size of 8 characters is assumed. | | find(...) | B.find(sub[, start[, end]]) -> int | | Return the lowest index in B where subsection sub is found, | such that sub is contained within B[start,end]. Optional | arguments start and end are interpreted as in slice notation. | | Return -1 on failure. | | hex(...) | Create a str of hexadecimal numbers from a bytes object. | | sep | An optional single character or byte to separate hex bytes. | bytes_per_sep | How many bytes between separators. Positive values count from the | right, negative values count from the left. | | Example: | >>> value = b'\xb9\x01\xef' | >>> value.hex() | 'b901ef' | >>> value.hex(':') | 'b9:01:ef' | >>> value.hex(':', 2) | 'b9:01ef' | >>> value.hex(':', -2) | 'b901:ef' | | index(...) | B.index(sub[, start[, end]]) -> int | | Return the lowest index in B where subsection sub is found, | such that sub is contained within B[start,end]. Optional | arguments start and end are interpreted as in slice notation. | | Raises ValueError when the subsection is not found. | | isalnum(...) | B.isalnum() -> bool | | Return True if all characters in B are alphanumeric | and there is at least one character in B, False otherwise. | | isalpha(...) | B.isalpha() -> bool | | Return True if all characters in B are alphabetic | and there is at least one character in B, False otherwise. | | isascii(...) | B.isascii() -> bool | | Return True if B is empty or all characters in B are ASCII, | False otherwise. | | isdigit(...) | B.isdigit() -> bool | | Return True if all characters in B are digits | and there is at least one character in B, False otherwise. | | islower(...) | B.islower() -> bool | | Return True if all cased characters in B are lowercase and there is | at least one cased character in B, False otherwise. | | isspace(...) | B.isspace() -> bool | | Return True if all characters in B are whitespace | and there is at least one character in B, False otherwise. | | istitle(...) | B.istitle() -> bool | | Return True if B is a titlecased string and there is at least one | character in B, i.e. uppercase characters may only follow uncased | characters and lowercase characters only cased ones. Return False | otherwise. | | isupper(...) | B.isupper() -> bool | | Return True if all cased characters in B are uppercase and there is | at least one cased character in B, False otherwise. | | join(self, iterable_of_bytes, /) | Concatenate any number of bytes objects. | | The bytes whose method is called is inserted in between each pair. | | The result is returned as a new bytes object. | | Example: b'.'.join([b'ab', b'pq', b'rs']) -> b'ab.pq.rs'. | | ljust(self, width, fillchar=b' ', /) | Return a left-justified string of length width. | | Padding is done using the specified fill character. | | lower(...) | B.lower() -> copy of B | | Return a copy of B with all ASCII characters converted to lowercase. | | lstrip(self, bytes=None, /) | Strip leading bytes contained in the argument. | | If the argument is omitted or None, strip leading ASCII whitespace. | | partition(self, sep, /) | Partition the bytes into three parts using the given separator. | | This will search for the separator sep in the bytes. If the separator is found, | returns a 3-tuple containing the part before the separator, the separator | itself, and the part after it. | | If the separator is not found, returns a 3-tuple containing the original bytes | object and two empty bytes objects. | | replace(self, old, new, count=-1, /) | Return a copy with all occurrences of substring old replaced by new. | | count | Maximum number of occurrences to replace. | -1 (the default value) means replace all occurrences. | | If the optional argument count is given, only the first count occurrences are | replaced. | | rfind(...) | B.rfind(sub[, start[, end]]) -> int | | Return the highest index in B where subsection sub is found, | such that sub is contained within B[start,end]. Optional | arguments start and end are interpreted as in slice notation. | | Return -1 on failure. | | rindex(...) | B.rindex(sub[, start[, end]]) -> int | | Return the highest index in B where subsection sub is found, | such that sub is contained within B[start,end]. Optional | arguments start and end are interpreted as in slice notation. | | Raise ValueError when the subsection is not found. | | rjust(self, width, fillchar=b' ', /) | Return a right-justified string of length width. | | Padding is done using the specified fill character. | | rpartition(self, sep, /) | Partition the bytes into three parts using the given separator. | | This will search for the separator sep in the bytes, starting at the end. If | the separator is found, returns a 3-tuple containing the part before the | separator, the separator itself, and the part after it. | | If the separator is not found, returns a 3-tuple containing two empty bytes | objects and the original bytes object. | | rsplit(self, /, sep=None, maxsplit=-1) | Return a list of the sections in the bytes, using sep as the delimiter. | | sep | The delimiter according which to split the bytes. | None (the default value) means split on ASCII whitespace characters | (space, tab, return, newline, formfeed, vertical tab). | maxsplit | Maximum number of splits to do. | -1 (the default value) means no limit. | | Splitting is done starting at the end of the bytes and working to the front. | | rstrip(self, bytes=None, /) | Strip trailing bytes contained in the argument. | | If the argument is omitted or None, strip trailing ASCII whitespace. | | split(self, /, sep=None, maxsplit=-1) | Return a list of the sections in the bytes, using sep as the delimiter. | | sep | The delimiter according which to split the bytes. | None (the default value) means split on ASCII whitespace characters | (space, tab, return, newline, formfeed, vertical tab). | maxsplit | Maximum number of splits to do. | -1 (the default value) means no limit. | | splitlines(self, /, keepends=False) | Return a list of the lines in the bytes, breaking at line boundaries. | | Line breaks are not included in the resulting list unless keepends is given and | true. | | startswith(...) | B.startswith(prefix[, start[, end]]) -> bool | | Return True if B starts with the specified prefix, False otherwise. | With optional start, test B beginning at that position. | With optional end, stop comparing B at that position. | prefix can also be a tuple of bytes to try. | | strip(self, bytes=None, /) | Strip leading and trailing bytes contained in the argument. | | If the argument is omitted or None, strip leading and trailing ASCII whitespace. | | swapcase(...) | B.swapcase() -> copy of B | | Return a copy of B with uppercase ASCII characters converted | to lowercase ASCII and vice versa. | | title(...) | B.title() -> copy of B | | Return a titlecased version of B, i.e. ASCII words start with uppercase | characters, all remaining cased characters have lowercase. | | translate(self, table, /, delete=b'') | Return a copy with each character mapped by the given translation table. | | table | Translation table, which must be a bytes object of length 256. | | All characters occurring in the optional argument delete are removed. | The remaining characters are mapped through the given translation table. | | upper(...) | B.upper() -> copy of B | | Return a copy of B with all ASCII characters converted to uppercase. | | zfill(self, width, /) | Pad a numeric string with zeros on the left, to fill a field of the given width. | | The original string is never truncated. | | ---------------------------------------------------------------------- | Class methods inherited from builtins.bytes: | | fromhex(string, /) from builtins.type | Create a bytes object from a string of hexadecimal numbers. | | Spaces between two numbers are accepted. | Example: bytes.fromhex('B9 01EF') -> b'\\xb9\\x01\\xef'. | | ---------------------------------------------------------------------- | Static methods inherited from builtins.bytes: | | maketrans(frm, to, /) | Return a translation table useable for the bytes or bytearray translate method. | | The returned table will be one where each byte in frm is mapped to the byte at | the same position in to. | | The bytes objects frm and to must be of the same length. | | ---------------------------------------------------------------------- | Methods inherited from generic: | | __abs__(self, /) | abs(self) | | __and__(self, value, /) | Return self&value. | | __array__(...) | sc.__array__(dtype) return 0-dim array from scalar with specified dtype | | __array_wrap__(...) | sc.__array_wrap__(obj) return scalar from array | | __bool__(self, /) | self != 0 | | __copy__(...) | | __deepcopy__(...) | | __divmod__(self, value, /) | Return divmod(self, value). | | __float__(self, /) | float(self) | | __floordiv__(self, value, /) | Return self//value. | | __format__(...) | NumPy array scalar formatter | | __int__(self, /) | int(self) | | __invert__(self, /) | ~self | | __lshift__(self, value, /) | Return self<<value. | | __neg__(self, /) | -self | | __or__(self, value, /) | Return self|value. | | __pos__(self, /) | +self | | __pow__(self, value, mod=None, /) | Return pow(self, value, mod). | | __radd__(self, value, /) | Return value+self. | | __rand__(self, value, /) | Return value&self. | | __rdivmod__(self, value, /) | Return divmod(value, self). | | __reduce__(...) | Helper for pickle. | | __rfloordiv__(self, value, /) | Return value//self. | | __rlshift__(self, value, /) | Return value<<self. | | __ror__(self, value, /) | Return value|self. | | __rpow__(self, value, mod=None, /) | Return pow(value, self, mod). | | __rrshift__(self, value, /) | Return value>>self. | | __rshift__(self, value, /) | Return self>>value. | | __rsub__(self, value, /) | Return value-self. | | __rtruediv__(self, value, /) | Return value/self. | | __rxor__(self, value, /) | Return value^self. | | __setstate__(...) | | __sizeof__(...) | Size of object in memory, in bytes. | | __sub__(self, value, /) | Return self-value. | | __truediv__(self, value, /) | Return self/value. | | __xor__(self, value, /) | Return self^value. | | all(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | getfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | base | base object | | data | pointer to start of data | | dtype | get array data-descriptor | | flags | integer value of flags | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension class timedelta64(signedinteger) | Abstract base class of all signed integer scalar types. | | Method resolution order: | timedelta64 | signedinteger | integer | number | generic | builtins.object | | Methods defined here: | | __eq__(self, value, /) | Return self==value. | | __ge__(self, value, /) | Return self>=value. | | __gt__(self, value, /) | Return self>value. | | __hash__(self, /) | Return hash(self). | | __le__(self, value, /) | Return self<=value. | | __lt__(self, value, /) | Return self<value. | | __ne__(self, value, /) | Return self!=value. | | __repr__(self, /) | Return repr(self). | | __str__(self, /) | Return str(self). | | ---------------------------------------------------------------------- | Static methods defined here: | | __new__(*args, **kwargs) from builtins.type | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Methods inherited from integer: | | __round__(...) | | ---------------------------------------------------------------------- | Data descriptors inherited from integer: | | denominator | denominator of value (1) | | numerator | numerator of value (the value itself) | | ---------------------------------------------------------------------- | Methods inherited from generic: | | __abs__(self, /) | abs(self) | | __add__(self, value, /) | Return self+value. | | __and__(self, value, /) | Return self&value. | | __array__(...) | sc.__array__(dtype) return 0-dim array from scalar with specified dtype | | __array_wrap__(...) | sc.__array_wrap__(obj) return scalar from array | | __bool__(self, /) | self != 0 | | __copy__(...) | | __deepcopy__(...) | | __divmod__(self, value, /) | Return divmod(self, value). | | __float__(self, /) | float(self) | | __floordiv__(self, value, /) | Return self//value. | | __format__(...) | NumPy array scalar formatter | | __getitem__(self, key, /) | Return self[key]. | | __int__(self, /) | int(self) | | __invert__(self, /) | ~self | | __lshift__(self, value, /) | Return self<<value. | | __mod__(self, value, /) | Return self%value. | | __mul__(self, value, /) | Return self*value. | | __neg__(self, /) | -self | | __or__(self, value, /) | Return self|value. | | __pos__(self, /) | +self | | __pow__(self, value, mod=None, /) | Return pow(self, value, mod). | | __radd__(self, value, /) | Return value+self. | | __rand__(self, value, /) | Return value&self. | | __rdivmod__(self, value, /) | Return divmod(value, self). | | __reduce__(...) | Helper for pickle. | | __rfloordiv__(self, value, /) | Return value//self. | | __rlshift__(self, value, /) | Return value<<self. | | __rmod__(self, value, /) | Return value%self. | | __rmul__(self, value, /) | Return value*self. | | __ror__(self, value, /) | Return value|self. | | __rpow__(self, value, mod=None, /) | Return pow(value, self, mod). | | __rrshift__(self, value, /) | Return value>>self. | | __rshift__(self, value, /) | Return self>>value. | | __rsub__(self, value, /) | Return value-self. | | __rtruediv__(self, value, /) | Return value/self. | | __rxor__(self, value, /) | Return value^self. | | __setstate__(...) | | __sizeof__(...) | Size of object in memory, in bytes. | | __sub__(self, value, /) | Return self-value. | | __truediv__(self, value, /) | Return self/value. | | __xor__(self, value, /) | Return self^value. | | all(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | getfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | base | base object | | data | pointer to start of data | | dtype | get array data-descriptor | | flags | integer value of flags | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension ubyte = class uint8(unsignedinteger) | Unsigned integer type, compatible with C ``unsigned char``. | Character code: ``'B'``. | Canonical name: ``np.ubyte``. | Alias *on this platform*: ``np.uint8``: 8-bit unsigned integer (0 to 255). | | Method resolution order: | uint8 | unsignedinteger | integer | number | generic | builtins.object | | Methods defined here: | | __abs__(self, /) | abs(self) | | __add__(self, value, /) | Return self+value. | | __and__(self, value, /) | Return self&value. | | __bool__(self, /) | self != 0 | | __divmod__(self, value, /) | Return divmod(self, value). | | __eq__(self, value, /) | Return self==value. | | __float__(self, /) | float(self) | | __floordiv__(self, value, /) | Return self//value. | | __ge__(self, value, /) | Return self>=value. | | __gt__(self, value, /) | Return self>value. | | __hash__(self, /) | Return hash(self). | | __index__(self, /) | Return self converted to an integer, if self is suitable for use as an index into a list. | | __int__(self, /) | int(self) | | __invert__(self, /) | ~self | | __le__(self, value, /) | Return self<=value. | | __lshift__(self, value, /) | Return self<<value. | | __lt__(self, value, /) | Return self<value. | | __mod__(self, value, /) | Return self%value. | | __mul__(self, value, /) | Return self*value. | | __ne__(self, value, /) | Return self!=value. | | __neg__(self, /) | -self | | __or__(self, value, /) | Return self|value. | | __pos__(self, /) | +self | | __pow__(self, value, mod=None, /) | Return pow(self, value, mod). | | __radd__(self, value, /) | Return value+self. | | __rand__(self, value, /) | Return value&self. | | __rdivmod__(self, value, /) | Return divmod(value, self). | | __repr__(self, /) | Return repr(self). | | __rfloordiv__(self, value, /) | Return value//self. | | __rlshift__(self, value, /) | Return value<<self. | | __rmod__(self, value, /) | Return value%self. | | __rmul__(self, value, /) | Return value*self. | | __ror__(self, value, /) | Return value|self. | | __rpow__(self, value, mod=None, /) | Return pow(value, self, mod). | | __rrshift__(self, value, /) | Return value>>self. | | __rshift__(self, value, /) | Return self>>value. | | __rsub__(self, value, /) | Return value-self. | | __rtruediv__(self, value, /) | Return value/self. | | __rxor__(self, value, /) | Return value^self. | | __str__(self, /) | Return str(self). | | __sub__(self, value, /) | Return self-value. | | __truediv__(self, value, /) | Return self/value. | | __xor__(self, value, /) | Return self^value. | | ---------------------------------------------------------------------- | Static methods defined here: | | __new__(*args, **kwargs) from builtins.type | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Methods inherited from integer: | | __round__(...) | | ---------------------------------------------------------------------- | Data descriptors inherited from integer: | | denominator | denominator of value (1) | | numerator | numerator of value (the value itself) | | ---------------------------------------------------------------------- | Methods inherited from generic: | | __array__(...) | sc.__array__(dtype) return 0-dim array from scalar with specified dtype | | __array_wrap__(...) | sc.__array_wrap__(obj) return scalar from array | | __copy__(...) | | __deepcopy__(...) | | __format__(...) | NumPy array scalar formatter | | __getitem__(self, key, /) | Return self[key]. | | __reduce__(...) | Helper for pickle. | | __setstate__(...) | | __sizeof__(...) | Size of object in memory, in bytes. | | all(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | getfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | base | base object | | data | pointer to start of data | | dtype | get array data-descriptor | | flags | integer value of flags | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension class ufunc(builtins.object) | Functions that operate element by element on whole arrays. | | To see the documentation for a specific ufunc, use `info`. For | example, ``np.info(np.sin)``. Because ufuncs are written in C | (for speed) and linked into Python with NumPy's ufunc facility, | Python's help() function finds this page whenever help() is called | on a ufunc. | | A detailed explanation of ufuncs can be found in the docs for :ref:`ufuncs`. | | Calling ufuncs: | =============== | | op(*x[, out], where=True, **kwargs) | Apply `op` to the arguments `*x` elementwise, broadcasting the arguments. | | The broadcasting rules are: | | * Dimensions of length 1 may be prepended to either array. | * Arrays may be repeated along dimensions of length 1. | | Parameters | ---------- | *x : array_like | Input arrays. | out : ndarray, None, or tuple of ndarray and None, optional | Alternate array object(s) in which to put the result; if provided, it | must have a shape that the inputs broadcast to. A tuple of arrays | (possible only as a keyword argument) must have length equal to the | number of outputs; use None for uninitialized outputs to be | allocated by the ufunc. | where : array_like, optional | This condition is broadcast over the input. At locations where the | condition is True, the `out` array will be set to the ufunc result. | Elsewhere, the `out` array will retain its original value. | Note that if an uninitialized `out` array is created via the default | ``out=None``, locations within it where the condition is False will | remain uninitialized. | **kwargs | For other keyword-only arguments, see the :ref:`ufunc docs <ufuncs.kwargs>`. | | Returns | ------- | r : ndarray or tuple of ndarray | `r` will have the shape that the arrays in `x` broadcast to; if `out` is | provided, it will be returned. If not, `r` will be allocated and | may contain uninitialized values. If the function has more than one | output, then the result will be a tuple of arrays. | | Methods defined here: | | __call__(self, /, *args, **kwargs) | Call self as a function. | | __repr__(self, /) | Return repr(self). | | __str__(self, /) | Return str(self). | | accumulate(...) | accumulate(array, axis=0, dtype=None, out=None) | | Accumulate the result of applying the operator to all elements. | | For a one-dimensional array, accumulate produces results equivalent to:: | | r = np.empty(len(A)) | t = op.identity # op = the ufunc being applied to A's elements | for i in range(len(A)): | t = op(t, A[i]) | r[i] = t | return r | | For example, add.accumulate() is equivalent to np.cumsum(). | | For a multi-dimensional array, accumulate is applied along only one | axis (axis zero by default; see Examples below) so repeated use is | necessary if one wants to accumulate over multiple axes. | | Parameters | ---------- | array : array_like | The array to act on. | axis : int, optional | The axis along which to apply the accumulation; default is zero. | dtype : data-type code, optional | The data-type used to represent the intermediate results. Defaults | to the data-type of the output array if such is provided, or the | the data-type of the input array if no output array is provided. | out : ndarray, None, or tuple of ndarray and None, optional | A location into which the result is stored. If not provided or None, | a freshly-allocated array is returned. For consistency with | ``ufunc.__call__``, if given as a keyword, this may be wrapped in a | 1-element tuple. | | .. versionchanged:: 1.13.0 | Tuples are allowed for keyword argument. | | Returns | ------- | r : ndarray | The accumulated values. If `out` was supplied, `r` is a reference to | `out`. | | Examples | -------- | 1-D array examples: | | >>> np.add.accumulate([2, 3, 5]) | array([ 2, 5, 10]) | >>> np.multiply.accumulate([2, 3, 5]) | array([ 2, 6, 30]) | | 2-D array examples: | | >>> I = np.eye(2) | >>> I | array([[1., 0.], | [0., 1.]]) | | Accumulate along axis 0 (rows), down columns: | | >>> np.add.accumulate(I, 0) | array([[1., 0.], | [1., 1.]]) | >>> np.add.accumulate(I) # no axis specified = axis zero | array([[1., 0.], | [1., 1.]]) | | Accumulate along axis 1 (columns), through rows: | | >>> np.add.accumulate(I, 1) | array([[1., 1.], | [0., 1.]]) | | at(...) | at(a, indices, b=None) | | Performs unbuffered in place operation on operand 'a' for elements | specified by 'indices'. For addition ufunc, this method is equivalent to | ``a[indices] += b``, except that results are accumulated for elements that | are indexed more than once. For example, ``a[[0,0]] += 1`` will only | increment the first element once because of buffering, whereas | ``add.at(a, [0,0], 1)`` will increment the first element twice. | | .. versionadded:: 1.8.0 | | Parameters | ---------- | a : array_like | The array to perform in place operation on. | indices : array_like or tuple | Array like index object or slice object for indexing into first | operand. If first operand has multiple dimensions, indices can be a | tuple of array like index objects or slice objects. | b : array_like | Second operand for ufuncs requiring two operands. Operand must be | broadcastable over first operand after indexing or slicing. | | Examples | -------- | Set items 0 and 1 to their negative values: | | >>> a = np.array([1, 2, 3, 4]) | >>> np.negative.at(a, [0, 1]) | >>> a | array([-1, -2, 3, 4]) | | Increment items 0 and 1, and increment item 2 twice: | | >>> a = np.array([1, 2, 3, 4]) | >>> np.add.at(a, [0, 1, 2, 2], 1) | >>> a | array([2, 3, 5, 4]) | | Add items 0 and 1 in first array to second array, | and store results in first array: | | >>> a = np.array([1, 2, 3, 4]) | >>> b = np.array([1, 2]) | >>> np.add.at(a, [0, 1], b) | >>> a | array([2, 4, 3, 4]) | | outer(...) | outer(A, B, **kwargs) | | Apply the ufunc `op` to all pairs (a, b) with a in `A` and b in `B`. | | Let ``M = A.ndim``, ``N = B.ndim``. Then the result, `C`, of | ``op.outer(A, B)`` is an array of dimension M + N such that: | | .. math:: C[i_0, ..., i_{M-1}, j_0, ..., j_{N-1}] = | op(A[i_0, ..., i_{M-1}], B[j_0, ..., j_{N-1}]) | | For `A` and `B` one-dimensional, this is equivalent to:: | | r = empty(len(A),len(B)) | for i in range(len(A)): | for j in range(len(B)): | r[i,j] = op(A[i], B[j]) # op = ufunc in question | | Parameters | ---------- | A : array_like | First array | B : array_like | Second array | kwargs : any | Arguments to pass on to the ufunc. Typically `dtype` or `out`. | | Returns | ------- | r : ndarray | Output array | | See Also | -------- | numpy.outer : A less powerful version of ``np.multiply.outer`` | that `ravel`\ s all inputs to 1D. This exists | primarily for compatibility with old code. | | tensordot : ``np.tensordot(a, b, axes=((), ()))`` and | ``np.multiply.outer(a, b)`` behave same for all | dimensions of a and b. | | Examples | -------- | >>> np.multiply.outer([1, 2, 3], [4, 5, 6]) | array([[ 4, 5, 6], | [ 8, 10, 12], | [12, 15, 18]]) | | A multi-dimensional example: | | >>> A = np.array([[1, 2, 3], [4, 5, 6]]) | >>> A.shape | (2, 3) | >>> B = np.array([[1, 2, 3, 4]]) | >>> B.shape | (1, 4) | >>> C = np.multiply.outer(A, B) | >>> C.shape; C | (2, 3, 1, 4) | array([[[[ 1, 2, 3, 4]], | [[ 2, 4, 6, 8]], | [[ 3, 6, 9, 12]]], | [[[ 4, 8, 12, 16]], | [[ 5, 10, 15, 20]], | [[ 6, 12, 18, 24]]]]) | | reduce(...) | reduce(a, axis=0, dtype=None, out=None, keepdims=False, initial=<no value>, where=True) | | Reduces `a`'s dimension by one, by applying ufunc along one axis. | | Let :math:`a.shape = (N_0, ..., N_i, ..., N_{M-1})`. Then | :math:`ufunc.reduce(a, axis=i)[k_0, ..,k_{i-1}, k_{i+1}, .., k_{M-1}]` = | the result of iterating `j` over :math:`range(N_i)`, cumulatively applying | ufunc to each :math:`a[k_0, ..,k_{i-1}, j, k_{i+1}, .., k_{M-1}]`. | For a one-dimensional array, reduce produces results equivalent to: | :: | | r = op.identity # op = ufunc | for i in range(len(A)): | r = op(r, A[i]) | return r | | For example, add.reduce() is equivalent to sum(). | | Parameters | ---------- | a : array_like | The array to act on. | axis : None or int or tuple of ints, optional | Axis or axes along which a reduction is performed. | The default (`axis` = 0) is perform a reduction over the first | dimension of the input array. `axis` may be negative, in | which case it counts from the last to the first axis. | | .. versionadded:: 1.7.0 | | If this is None, a reduction is performed over all the axes. | If this is a tuple of ints, a reduction is performed on multiple | axes, instead of a single axis or all the axes as before. | | For operations which are either not commutative or not associative, | doing a reduction over multiple axes is not well-defined. The | ufuncs do not currently raise an exception in this case, but will | likely do so in the future. | dtype : data-type code, optional | The type used to represent the intermediate results. Defaults | to the data-type of the output array if this is provided, or | the data-type of the input array if no output array is provided. | out : ndarray, None, or tuple of ndarray and None, optional | A location into which the result is stored. If not provided or None, | a freshly-allocated array is returned. For consistency with | ``ufunc.__call__``, if given as a keyword, this may be wrapped in a | 1-element tuple. | | .. versionchanged:: 1.13.0 | Tuples are allowed for keyword argument. | keepdims : bool, optional | If this is set to True, the axes which are reduced are left | in the result as dimensions with size one. With this option, | the result will broadcast correctly against the original `arr`. | | .. versionadded:: 1.7.0 | initial : scalar, optional | The value with which to start the reduction. | If the ufunc has no identity or the dtype is object, this defaults | to None - otherwise it defaults to ufunc.identity. | If ``None`` is given, the first element of the reduction is used, | and an error is thrown if the reduction is empty. | | .. versionadded:: 1.15.0 | | where : array_like of bool, optional | A boolean array which is broadcasted to match the dimensions | of `a`, and selects elements to include in the reduction. Note | that for ufuncs like ``minimum`` that do not have an identity | defined, one has to pass in also ``initial``. | | .. versionadded:: 1.17.0 | | Returns | ------- | r : ndarray | The reduced array. If `out` was supplied, `r` is a reference to it. | | Examples | -------- | >>> np.multiply.reduce([2,3,5]) | 30 | | A multi-dimensional array example: | | >>> X = np.arange(8).reshape((2,2,2)) | >>> X | array([[[0, 1], | [2, 3]], | [[4, 5], | [6, 7]]]) | >>> np.add.reduce(X, 0) | array([[ 4, 6], | [ 8, 10]]) | >>> np.add.reduce(X) # confirm: default axis value is 0 | array([[ 4, 6], | [ 8, 10]]) | >>> np.add.reduce(X, 1) | array([[ 2, 4], | [10, 12]]) | >>> np.add.reduce(X, 2) | array([[ 1, 5], | [ 9, 13]]) | | You can use the ``initial`` keyword argument to initialize the reduction | with a different value, and ``where`` to select specific elements to include: | | >>> np.add.reduce([10], initial=5) | 15 | >>> np.add.reduce(np.ones((2, 2, 2)), axis=(0, 2), initial=10) | array([14., 14.]) | >>> a = np.array([10., np.nan, 10]) | >>> np.add.reduce(a, where=~np.isnan(a)) | 20.0 | | Allows reductions of empty arrays where they would normally fail, i.e. | for ufuncs without an identity. | | >>> np.minimum.reduce([], initial=np.inf) | inf | >>> np.minimum.reduce([[1., 2.], [3., 4.]], initial=10., where=[True, False]) | array([ 1., 10.]) | >>> np.minimum.reduce([]) | Traceback (most recent call last): | ... | ValueError: zero-size array to reduction operation minimum which has no identity | | reduceat(...) | reduceat(a, indices, axis=0, dtype=None, out=None) | | Performs a (local) reduce with specified slices over a single axis. | | For i in ``range(len(indices))``, `reduceat` computes | ``ufunc.reduce(a[indices[i]:indices[i+1]])``, which becomes the i-th | generalized "row" parallel to `axis` in the final result (i.e., in a | 2-D array, for example, if `axis = 0`, it becomes the i-th row, but if | `axis = 1`, it becomes the i-th column). There are three exceptions to this: | | * when ``i = len(indices) - 1`` (so for the last index), | ``indices[i+1] = a.shape[axis]``. | * if ``indices[i] >= indices[i + 1]``, the i-th generalized "row" is | simply ``a[indices[i]]``. | * if ``indices[i] >= len(a)`` or ``indices[i] < 0``, an error is raised. | | The shape of the output depends on the size of `indices`, and may be | larger than `a` (this happens if ``len(indices) > a.shape[axis]``). | | Parameters | ---------- | a : array_like | The array to act on. | indices : array_like | Paired indices, comma separated (not colon), specifying slices to | reduce. | axis : int, optional | The axis along which to apply the reduceat. | dtype : data-type code, optional | The type used to represent the intermediate results. Defaults | to the data type of the output array if this is provided, or | the data type of the input array if no output array is provided. | out : ndarray, None, or tuple of ndarray and None, optional | A location into which the result is stored. If not provided or None, | a freshly-allocated array is returned. For consistency with | ``ufunc.__call__``, if given as a keyword, this may be wrapped in a | 1-element tuple. | | .. versionchanged:: 1.13.0 | Tuples are allowed for keyword argument. | | Returns | ------- | r : ndarray | The reduced values. If `out` was supplied, `r` is a reference to | `out`. | | Notes | ----- | A descriptive example: | | If `a` is 1-D, the function `ufunc.accumulate(a)` is the same as | ``ufunc.reduceat(a, indices)[::2]`` where `indices` is | ``range(len(array) - 1)`` with a zero placed | in every other element: | ``indices = zeros(2 * len(a) - 1)``, ``indices[1::2] = range(1, len(a))``. | | Don't be fooled by this attribute's name: `reduceat(a)` is not | necessarily smaller than `a`. | | Examples | -------- | To take the running sum of four successive values: | | >>> np.add.reduceat(np.arange(8),[0,4, 1,5, 2,6, 3,7])[::2] | array([ 6, 10, 14, 18]) | | A 2-D example: | | >>> x = np.linspace(0, 15, 16).reshape(4,4) | >>> x | array([[ 0., 1., 2., 3.], | [ 4., 5., 6., 7.], | [ 8., 9., 10., 11.], | [12., 13., 14., 15.]]) | | :: | | # reduce such that the result has the following five rows: | # [row1 + row2 + row3] | # [row4] | # [row2] | # [row3] | # [row1 + row2 + row3 + row4] | | >>> np.add.reduceat(x, [0, 3, 1, 2, 0]) | array([[12., 15., 18., 21.], | [12., 13., 14., 15.], | [ 4., 5., 6., 7.], | [ 8., 9., 10., 11.], | [24., 28., 32., 36.]]) | | :: | | # reduce such that result has the following two columns: | # [col1 * col2 * col3, col4] | | >>> np.multiply.reduceat(x, [0, 3], 1) | array([[ 0., 3.], | [ 120., 7.], | [ 720., 11.], | [2184., 15.]]) | | ---------------------------------------------------------------------- | Data descriptors defined here: | | identity | The identity value. | | Data attribute containing the identity element for the ufunc, if it has one. | If it does not, the attribute value is None. | | Examples | -------- | >>> np.add.identity | 0 | >>> np.multiply.identity | 1 | >>> np.power.identity | 1 | >>> print(np.exp.identity) | None | | nargs | The number of arguments. | | Data attribute containing the number of arguments the ufunc takes, including | optional ones. | | Notes | ----- | Typically this value will be one more than what you might expect because all | ufuncs take the optional "out" argument. | | Examples | -------- | >>> np.add.nargs | 3 | >>> np.multiply.nargs | 3 | >>> np.power.nargs | 3 | >>> np.exp.nargs | 2 | | nin | The number of inputs. | | Data attribute containing the number of arguments the ufunc treats as input. | | Examples | -------- | >>> np.add.nin | 2 | >>> np.multiply.nin | 2 | >>> np.power.nin | 2 | >>> np.exp.nin | 1 | | nout | The number of outputs. | | Data attribute containing the number of arguments the ufunc treats as output. | | Notes | ----- | Since all ufuncs can take output arguments, this will always be (at least) 1. | | Examples | -------- | >>> np.add.nout | 1 | >>> np.multiply.nout | 1 | >>> np.power.nout | 1 | >>> np.exp.nout | 1 | | ntypes | The number of types. | | The number of numerical NumPy types - of which there are 18 total - on which | the ufunc can operate. | | See Also | -------- | numpy.ufunc.types | | Examples | -------- | >>> np.add.ntypes | 18 | >>> np.multiply.ntypes | 18 | >>> np.power.ntypes | 17 | >>> np.exp.ntypes | 7 | >>> np.remainder.ntypes | 14 | | signature | Definition of the core elements a generalized ufunc operates on. | | The signature determines how the dimensions of each input/output array | are split into core and loop dimensions: | | 1. Each dimension in the signature is matched to a dimension of the | corresponding passed-in array, starting from the end of the shape tuple. | 2. Core dimensions assigned to the same label in the signature must have | exactly matching sizes, no broadcasting is performed. | 3. The core dimensions are removed from all inputs and the remaining | dimensions are broadcast together, defining the loop dimensions. | | Notes | ----- | Generalized ufuncs are used internally in many linalg functions, and in | the testing suite; the examples below are taken from these. | For ufuncs that operate on scalars, the signature is None, which is | equivalent to '()' for every argument. | | Examples | -------- | >>> np.core.umath_tests.matrix_multiply.signature | '(m,n),(n,p)->(m,p)' | >>> np.linalg._umath_linalg.det.signature | '(m,m)->()' | >>> np.add.signature is None | True # equivalent to '(),()->()' | | types | Returns a list with types grouped input->output. | | Data attribute listing the data-type "Domain-Range" groupings the ufunc can | deliver. The data-types are given using the character codes. | | See Also | -------- | numpy.ufunc.ntypes | | Examples | -------- | >>> np.add.types | ['??->?', 'bb->b', 'BB->B', 'hh->h', 'HH->H', 'ii->i', 'II->I', 'll->l', | 'LL->L', 'qq->q', 'QQ->Q', 'ff->f', 'dd->d', 'gg->g', 'FF->F', 'DD->D', | 'GG->G', 'OO->O'] | | >>> np.multiply.types | ['??->?', 'bb->b', 'BB->B', 'hh->h', 'HH->H', 'ii->i', 'II->I', 'll->l', | 'LL->L', 'qq->q', 'QQ->Q', 'ff->f', 'dd->d', 'gg->g', 'FF->F', 'DD->D', | 'GG->G', 'OO->O'] | | >>> np.power.types | ['bb->b', 'BB->B', 'hh->h', 'HH->H', 'ii->i', 'II->I', 'll->l', 'LL->L', | 'qq->q', 'QQ->Q', 'ff->f', 'dd->d', 'gg->g', 'FF->F', 'DD->D', 'GG->G', | 'OO->O'] | | >>> np.exp.types | ['f->f', 'd->d', 'g->g', 'F->F', 'D->D', 'G->G', 'O->O'] | | >>> np.remainder.types | ['bb->b', 'BB->B', 'hh->h', 'HH->H', 'ii->i', 'II->I', 'll->l', 'LL->L', | 'qq->q', 'QQ->Q', 'ff->f', 'dd->d', 'gg->g', 'OO->O'] uint = class uint64(unsignedinteger) | Unsigned integer type, compatible with C ``unsigned long``. | Character code: ``'L'``. | Canonical name: ``np.uint``. | Alias *on this platform*: ``np.uint64``: 64-bit unsigned integer (0 to 18446744073709551615). | Alias *on this platform*: ``np.uintp``: Unsigned integer large enough to fit pointer, compatible with C ``uintptr_t``. | | Method resolution order: | uint64 | unsignedinteger | integer | number | generic | builtins.object | | Methods defined here: | | __abs__(self, /) | abs(self) | | __add__(self, value, /) | Return self+value. | | __and__(self, value, /) | Return self&value. | | __bool__(self, /) | self != 0 | | __divmod__(self, value, /) | Return divmod(self, value). | | __eq__(self, value, /) | Return self==value. | | __float__(self, /) | float(self) | | __floordiv__(self, value, /) | Return self//value. | | __ge__(self, value, /) | Return self>=value. | | __gt__(self, value, /) | Return self>value. | | __hash__(self, /) | Return hash(self). | | __index__(self, /) | Return self converted to an integer, if self is suitable for use as an index into a list. | | __int__(self, /) | int(self) | | __invert__(self, /) | ~self | | __le__(self, value, /) | Return self<=value. | | __lshift__(self, value, /) | Return self<<value. | | __lt__(self, value, /) | Return self<value. | | __mod__(self, value, /) | Return self%value. | | __mul__(self, value, /) | Return self*value. | | __ne__(self, value, /) | Return self!=value. | | __neg__(self, /) | -self | | __or__(self, value, /) | Return self|value. | | __pos__(self, /) | +self | | __pow__(self, value, mod=None, /) | Return pow(self, value, mod). | | __radd__(self, value, /) | Return value+self. | | __rand__(self, value, /) | Return value&self. | | __rdivmod__(self, value, /) | Return divmod(value, self). | | __repr__(self, /) | Return repr(self). | | __rfloordiv__(self, value, /) | Return value//self. | | __rlshift__(self, value, /) | Return value<<self. | | __rmod__(self, value, /) | Return value%self. | | __rmul__(self, value, /) | Return value*self. | | __ror__(self, value, /) | Return value|self. | | __rpow__(self, value, mod=None, /) | Return pow(value, self, mod). | | __rrshift__(self, value, /) | Return value>>self. | | __rshift__(self, value, /) | Return self>>value. | | __rsub__(self, value, /) | Return value-self. | | __rtruediv__(self, value, /) | Return value/self. | | __rxor__(self, value, /) | Return value^self. | | __str__(self, /) | Return str(self). | | __sub__(self, value, /) | Return self-value. | | __truediv__(self, value, /) | Return self/value. | | __xor__(self, value, /) | Return self^value. | | ---------------------------------------------------------------------- | Static methods defined here: | | __new__(*args, **kwargs) from builtins.type | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Methods inherited from integer: | | __round__(...) | | ---------------------------------------------------------------------- | Data descriptors inherited from integer: | | denominator | denominator of value (1) | | numerator | numerator of value (the value itself) | | ---------------------------------------------------------------------- | Methods inherited from generic: | | __array__(...) | sc.__array__(dtype) return 0-dim array from scalar with specified dtype | | __array_wrap__(...) | sc.__array_wrap__(obj) return scalar from array | | __copy__(...) | | __deepcopy__(...) | | __format__(...) | NumPy array scalar formatter | | __getitem__(self, key, /) | Return self[key]. | | __reduce__(...) | Helper for pickle. | | __setstate__(...) | | __sizeof__(...) | Size of object in memory, in bytes. | | all(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | getfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | base | base object | | data | pointer to start of data | | dtype | get array data-descriptor | | flags | integer value of flags | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension uint0 = class uint64(unsignedinteger) | Unsigned integer type, compatible with C ``unsigned long``. | Character code: ``'L'``. | Canonical name: ``np.uint``. | Alias *on this platform*: ``np.uint64``: 64-bit unsigned integer (0 to 18446744073709551615). | Alias *on this platform*: ``np.uintp``: Unsigned integer large enough to fit pointer, compatible with C ``uintptr_t``. | | Method resolution order: | uint64 | unsignedinteger | integer | number | generic | builtins.object | | Methods defined here: | | __abs__(self, /) | abs(self) | | __add__(self, value, /) | Return self+value. | | __and__(self, value, /) | Return self&value. | | __bool__(self, /) | self != 0 | | __divmod__(self, value, /) | Return divmod(self, value). | | __eq__(self, value, /) | Return self==value. | | __float__(self, /) | float(self) | | __floordiv__(self, value, /) | Return self//value. | | __ge__(self, value, /) | Return self>=value. | | __gt__(self, value, /) | Return self>value. | | __hash__(self, /) | Return hash(self). | | __index__(self, /) | Return self converted to an integer, if self is suitable for use as an index into a list. | | __int__(self, /) | int(self) | | __invert__(self, /) | ~self | | __le__(self, value, /) | Return self<=value. | | __lshift__(self, value, /) | Return self<<value. | | __lt__(self, value, /) | Return self<value. | | __mod__(self, value, /) | Return self%value. | | __mul__(self, value, /) | Return self*value. | | __ne__(self, value, /) | Return self!=value. | | __neg__(self, /) | -self | | __or__(self, value, /) | Return self|value. | | __pos__(self, /) | +self | | __pow__(self, value, mod=None, /) | Return pow(self, value, mod). | | __radd__(self, value, /) | Return value+self. | | __rand__(self, value, /) | Return value&self. | | __rdivmod__(self, value, /) | Return divmod(value, self). | | __repr__(self, /) | Return repr(self). | | __rfloordiv__(self, value, /) | Return value//self. | | __rlshift__(self, value, /) | Return value<<self. | | __rmod__(self, value, /) | Return value%self. | | __rmul__(self, value, /) | Return value*self. | | __ror__(self, value, /) | Return value|self. | | __rpow__(self, value, mod=None, /) | Return pow(value, self, mod). | | __rrshift__(self, value, /) | Return value>>self. | | __rshift__(self, value, /) | Return self>>value. | | __rsub__(self, value, /) | Return value-self. | | __rtruediv__(self, value, /) | Return value/self. | | __rxor__(self, value, /) | Return value^self. | | __str__(self, /) | Return str(self). | | __sub__(self, value, /) | Return self-value. | | __truediv__(self, value, /) | Return self/value. | | __xor__(self, value, /) | Return self^value. | | ---------------------------------------------------------------------- | Static methods defined here: | | __new__(*args, **kwargs) from builtins.type | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Methods inherited from integer: | | __round__(...) | | ---------------------------------------------------------------------- | Data descriptors inherited from integer: | | denominator | denominator of value (1) | | numerator | numerator of value (the value itself) | | ---------------------------------------------------------------------- | Methods inherited from generic: | | __array__(...) | sc.__array__(dtype) return 0-dim array from scalar with specified dtype | | __array_wrap__(...) | sc.__array_wrap__(obj) return scalar from array | | __copy__(...) | | __deepcopy__(...) | | __format__(...) | NumPy array scalar formatter | | __getitem__(self, key, /) | Return self[key]. | | __reduce__(...) | Helper for pickle. | | __setstate__(...) | | __sizeof__(...) | Size of object in memory, in bytes. | | all(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | getfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | base | base object | | data | pointer to start of data | | dtype | get array data-descriptor | | flags | integer value of flags | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension class uint16(unsignedinteger) | Unsigned integer type, compatible with C ``unsigned short``. | Character code: ``'H'``. | Canonical name: ``np.ushort``. | Alias *on this platform*: ``np.uint16``: 16-bit unsigned integer (0 to 65535). | | Method resolution order: | uint16 | unsignedinteger | integer | number | generic | builtins.object | | Methods defined here: | | __abs__(self, /) | abs(self) | | __add__(self, value, /) | Return self+value. | | __and__(self, value, /) | Return self&value. | | __bool__(self, /) | self != 0 | | __divmod__(self, value, /) | Return divmod(self, value). | | __eq__(self, value, /) | Return self==value. | | __float__(self, /) | float(self) | | __floordiv__(self, value, /) | Return self//value. | | __ge__(self, value, /) | Return self>=value. | | __gt__(self, value, /) | Return self>value. | | __hash__(self, /) | Return hash(self). | | __index__(self, /) | Return self converted to an integer, if self is suitable for use as an index into a list. | | __int__(self, /) | int(self) | | __invert__(self, /) | ~self | | __le__(self, value, /) | Return self<=value. | | __lshift__(self, value, /) | Return self<<value. | | __lt__(self, value, /) | Return self<value. | | __mod__(self, value, /) | Return self%value. | | __mul__(self, value, /) | Return self*value. | | __ne__(self, value, /) | Return self!=value. | | __neg__(self, /) | -self | | __or__(self, value, /) | Return self|value. | | __pos__(self, /) | +self | | __pow__(self, value, mod=None, /) | Return pow(self, value, mod). | | __radd__(self, value, /) | Return value+self. | | __rand__(self, value, /) | Return value&self. | | __rdivmod__(self, value, /) | Return divmod(value, self). | | __repr__(self, /) | Return repr(self). | | __rfloordiv__(self, value, /) | Return value//self. | | __rlshift__(self, value, /) | Return value<<self. | | __rmod__(self, value, /) | Return value%self. | | __rmul__(self, value, /) | Return value*self. | | __ror__(self, value, /) | Return value|self. | | __rpow__(self, value, mod=None, /) | Return pow(value, self, mod). | | __rrshift__(self, value, /) | Return value>>self. | | __rshift__(self, value, /) | Return self>>value. | | __rsub__(self, value, /) | Return value-self. | | __rtruediv__(self, value, /) | Return value/self. | | __rxor__(self, value, /) | Return value^self. | | __str__(self, /) | Return str(self). | | __sub__(self, value, /) | Return self-value. | | __truediv__(self, value, /) | Return self/value. | | __xor__(self, value, /) | Return self^value. | | ---------------------------------------------------------------------- | Static methods defined here: | | __new__(*args, **kwargs) from builtins.type | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Methods inherited from integer: | | __round__(...) | | ---------------------------------------------------------------------- | Data descriptors inherited from integer: | | denominator | denominator of value (1) | | numerator | numerator of value (the value itself) | | ---------------------------------------------------------------------- | Methods inherited from generic: | | __array__(...) | sc.__array__(dtype) return 0-dim array from scalar with specified dtype | | __array_wrap__(...) | sc.__array_wrap__(obj) return scalar from array | | __copy__(...) | | __deepcopy__(...) | | __format__(...) | NumPy array scalar formatter | | __getitem__(self, key, /) | Return self[key]. | | __reduce__(...) | Helper for pickle. | | __setstate__(...) | | __sizeof__(...) | Size of object in memory, in bytes. | | all(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | getfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | base | base object | | data | pointer to start of data | | dtype | get array data-descriptor | | flags | integer value of flags | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension class uint32(unsignedinteger) | Unsigned integer type, compatible with C ``unsigned int``. | Character code: ``'I'``. | Canonical name: ``np.uintc``. | Alias *on this platform*: ``np.uint32``: 32-bit unsigned integer (0 to 4294967295). | | Method resolution order: | uint32 | unsignedinteger | integer | number | generic | builtins.object | | Methods defined here: | | __abs__(self, /) | abs(self) | | __add__(self, value, /) | Return self+value. | | __and__(self, value, /) | Return self&value. | | __bool__(self, /) | self != 0 | | __divmod__(self, value, /) | Return divmod(self, value). | | __eq__(self, value, /) | Return self==value. | | __float__(self, /) | float(self) | | __floordiv__(self, value, /) | Return self//value. | | __ge__(self, value, /) | Return self>=value. | | __gt__(self, value, /) | Return self>value. | | __hash__(self, /) | Return hash(self). | | __index__(self, /) | Return self converted to an integer, if self is suitable for use as an index into a list. | | __int__(self, /) | int(self) | | __invert__(self, /) | ~self | | __le__(self, value, /) | Return self<=value. | | __lshift__(self, value, /) | Return self<<value. | | __lt__(self, value, /) | Return self<value. | | __mod__(self, value, /) | Return self%value. | | __mul__(self, value, /) | Return self*value. | | __ne__(self, value, /) | Return self!=value. | | __neg__(self, /) | -self | | __or__(self, value, /) | Return self|value. | | __pos__(self, /) | +self | | __pow__(self, value, mod=None, /) | Return pow(self, value, mod). | | __radd__(self, value, /) | Return value+self. | | __rand__(self, value, /) | Return value&self. | | __rdivmod__(self, value, /) | Return divmod(value, self). | | __repr__(self, /) | Return repr(self). | | __rfloordiv__(self, value, /) | Return value//self. | | __rlshift__(self, value, /) | Return value<<self. | | __rmod__(self, value, /) | Return value%self. | | __rmul__(self, value, /) | Return value*self. | | __ror__(self, value, /) | Return value|self. | | __rpow__(self, value, mod=None, /) | Return pow(value, self, mod). | | __rrshift__(self, value, /) | Return value>>self. | | __rshift__(self, value, /) | Return self>>value. | | __rsub__(self, value, /) | Return value-self. | | __rtruediv__(self, value, /) | Return value/self. | | __rxor__(self, value, /) | Return value^self. | | __str__(self, /) | Return str(self). | | __sub__(self, value, /) | Return self-value. | | __truediv__(self, value, /) | Return self/value. | | __xor__(self, value, /) | Return self^value. | | ---------------------------------------------------------------------- | Static methods defined here: | | __new__(*args, **kwargs) from builtins.type | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Methods inherited from integer: | | __round__(...) | | ---------------------------------------------------------------------- | Data descriptors inherited from integer: | | denominator | denominator of value (1) | | numerator | numerator of value (the value itself) | | ---------------------------------------------------------------------- | Methods inherited from generic: | | __array__(...) | sc.__array__(dtype) return 0-dim array from scalar with specified dtype | | __array_wrap__(...) | sc.__array_wrap__(obj) return scalar from array | | __copy__(...) | | __deepcopy__(...) | | __format__(...) | NumPy array scalar formatter | | __getitem__(self, key, /) | Return self[key]. | | __reduce__(...) | Helper for pickle. | | __setstate__(...) | | __sizeof__(...) | Size of object in memory, in bytes. | | all(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | getfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | base | base object | | data | pointer to start of data | | dtype | get array data-descriptor | | flags | integer value of flags | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension class uint64(unsignedinteger) | Unsigned integer type, compatible with C ``unsigned long``. | Character code: ``'L'``. | Canonical name: ``np.uint``. | Alias *on this platform*: ``np.uint64``: 64-bit unsigned integer (0 to 18446744073709551615). | Alias *on this platform*: ``np.uintp``: Unsigned integer large enough to fit pointer, compatible with C ``uintptr_t``. | | Method resolution order: | uint64 | unsignedinteger | integer | number | generic | builtins.object | | Methods defined here: | | __abs__(self, /) | abs(self) | | __add__(self, value, /) | Return self+value. | | __and__(self, value, /) | Return self&value. | | __bool__(self, /) | self != 0 | | __divmod__(self, value, /) | Return divmod(self, value). | | __eq__(self, value, /) | Return self==value. | | __float__(self, /) | float(self) | | __floordiv__(self, value, /) | Return self//value. | | __ge__(self, value, /) | Return self>=value. | | __gt__(self, value, /) | Return self>value. | | __hash__(self, /) | Return hash(self). | | __index__(self, /) | Return self converted to an integer, if self is suitable for use as an index into a list. | | __int__(self, /) | int(self) | | __invert__(self, /) | ~self | | __le__(self, value, /) | Return self<=value. | | __lshift__(self, value, /) | Return self<<value. | | __lt__(self, value, /) | Return self<value. | | __mod__(self, value, /) | Return self%value. | | __mul__(self, value, /) | Return self*value. | | __ne__(self, value, /) | Return self!=value. | | __neg__(self, /) | -self | | __or__(self, value, /) | Return self|value. | | __pos__(self, /) | +self | | __pow__(self, value, mod=None, /) | Return pow(self, value, mod). | | __radd__(self, value, /) | Return value+self. | | __rand__(self, value, /) | Return value&self. | | __rdivmod__(self, value, /) | Return divmod(value, self). | | __repr__(self, /) | Return repr(self). | | __rfloordiv__(self, value, /) | Return value//self. | | __rlshift__(self, value, /) | Return value<<self. | | __rmod__(self, value, /) | Return value%self. | | __rmul__(self, value, /) | Return value*self. | | __ror__(self, value, /) | Return value|self. | | __rpow__(self, value, mod=None, /) | Return pow(value, self, mod). | | __rrshift__(self, value, /) | Return value>>self. | | __rshift__(self, value, /) | Return self>>value. | | __rsub__(self, value, /) | Return value-self. | | __rtruediv__(self, value, /) | Return value/self. | | __rxor__(self, value, /) | Return value^self. | | __str__(self, /) | Return str(self). | | __sub__(self, value, /) | Return self-value. | | __truediv__(self, value, /) | Return self/value. | | __xor__(self, value, /) | Return self^value. | | ---------------------------------------------------------------------- | Static methods defined here: | | __new__(*args, **kwargs) from builtins.type | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Methods inherited from integer: | | __round__(...) | | ---------------------------------------------------------------------- | Data descriptors inherited from integer: | | denominator | denominator of value (1) | | numerator | numerator of value (the value itself) | | ---------------------------------------------------------------------- | Methods inherited from generic: | | __array__(...) | sc.__array__(dtype) return 0-dim array from scalar with specified dtype | | __array_wrap__(...) | sc.__array_wrap__(obj) return scalar from array | | __copy__(...) | | __deepcopy__(...) | | __format__(...) | NumPy array scalar formatter | | __getitem__(self, key, /) | Return self[key]. | | __reduce__(...) | Helper for pickle. | | __setstate__(...) | | __sizeof__(...) | Size of object in memory, in bytes. | | all(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | getfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | base | base object | | data | pointer to start of data | | dtype | get array data-descriptor | | flags | integer value of flags | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension class uint8(unsignedinteger) | Unsigned integer type, compatible with C ``unsigned char``. | Character code: ``'B'``. | Canonical name: ``np.ubyte``. | Alias *on this platform*: ``np.uint8``: 8-bit unsigned integer (0 to 255). | | Method resolution order: | uint8 | unsignedinteger | integer | number | generic | builtins.object | | Methods defined here: | | __abs__(self, /) | abs(self) | | __add__(self, value, /) | Return self+value. | | __and__(self, value, /) | Return self&value. | | __bool__(self, /) | self != 0 | | __divmod__(self, value, /) | Return divmod(self, value). | | __eq__(self, value, /) | Return self==value. | | __float__(self, /) | float(self) | | __floordiv__(self, value, /) | Return self//value. | | __ge__(self, value, /) | Return self>=value. | | __gt__(self, value, /) | Return self>value. | | __hash__(self, /) | Return hash(self). | | __index__(self, /) | Return self converted to an integer, if self is suitable for use as an index into a list. | | __int__(self, /) | int(self) | | __invert__(self, /) | ~self | | __le__(self, value, /) | Return self<=value. | | __lshift__(self, value, /) | Return self<<value. | | __lt__(self, value, /) | Return self<value. | | __mod__(self, value, /) | Return self%value. | | __mul__(self, value, /) | Return self*value. | | __ne__(self, value, /) | Return self!=value. | | __neg__(self, /) | -self | | __or__(self, value, /) | Return self|value. | | __pos__(self, /) | +self | | __pow__(self, value, mod=None, /) | Return pow(self, value, mod). | | __radd__(self, value, /) | Return value+self. | | __rand__(self, value, /) | Return value&self. | | __rdivmod__(self, value, /) | Return divmod(value, self). | | __repr__(self, /) | Return repr(self). | | __rfloordiv__(self, value, /) | Return value//self. | | __rlshift__(self, value, /) | Return value<<self. | | __rmod__(self, value, /) | Return value%self. | | __rmul__(self, value, /) | Return value*self. | | __ror__(self, value, /) | Return value|self. | | __rpow__(self, value, mod=None, /) | Return pow(value, self, mod). | | __rrshift__(self, value, /) | Return value>>self. | | __rshift__(self, value, /) | Return self>>value. | | __rsub__(self, value, /) | Return value-self. | | __rtruediv__(self, value, /) | Return value/self. | | __rxor__(self, value, /) | Return value^self. | | __str__(self, /) | Return str(self). | | __sub__(self, value, /) | Return self-value. | | __truediv__(self, value, /) | Return self/value. | | __xor__(self, value, /) | Return self^value. | | ---------------------------------------------------------------------- | Static methods defined here: | | __new__(*args, **kwargs) from builtins.type | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Methods inherited from integer: | | __round__(...) | | ---------------------------------------------------------------------- | Data descriptors inherited from integer: | | denominator | denominator of value (1) | | numerator | numerator of value (the value itself) | | ---------------------------------------------------------------------- | Methods inherited from generic: | | __array__(...) | sc.__array__(dtype) return 0-dim array from scalar with specified dtype | | __array_wrap__(...) | sc.__array_wrap__(obj) return scalar from array | | __copy__(...) | | __deepcopy__(...) | | __format__(...) | NumPy array scalar formatter | | __getitem__(self, key, /) | Return self[key]. | | __reduce__(...) | Helper for pickle. | | __setstate__(...) | | __sizeof__(...) | Size of object in memory, in bytes. | | all(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | getfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | base | base object | | data | pointer to start of data | | dtype | get array data-descriptor | | flags | integer value of flags | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension uintc = class uint32(unsignedinteger) | Unsigned integer type, compatible with C ``unsigned int``. | Character code: ``'I'``. | Canonical name: ``np.uintc``. | Alias *on this platform*: ``np.uint32``: 32-bit unsigned integer (0 to 4294967295). | | Method resolution order: | uint32 | unsignedinteger | integer | number | generic | builtins.object | | Methods defined here: | | __abs__(self, /) | abs(self) | | __add__(self, value, /) | Return self+value. | | __and__(self, value, /) | Return self&value. | | __bool__(self, /) | self != 0 | | __divmod__(self, value, /) | Return divmod(self, value). | | __eq__(self, value, /) | Return self==value. | | __float__(self, /) | float(self) | | __floordiv__(self, value, /) | Return self//value. | | __ge__(self, value, /) | Return self>=value. | | __gt__(self, value, /) | Return self>value. | | __hash__(self, /) | Return hash(self). | | __index__(self, /) | Return self converted to an integer, if self is suitable for use as an index into a list. | | __int__(self, /) | int(self) | | __invert__(self, /) | ~self | | __le__(self, value, /) | Return self<=value. | | __lshift__(self, value, /) | Return self<<value. | | __lt__(self, value, /) | Return self<value. | | __mod__(self, value, /) | Return self%value. | | __mul__(self, value, /) | Return self*value. | | __ne__(self, value, /) | Return self!=value. | | __neg__(self, /) | -self | | __or__(self, value, /) | Return self|value. | | __pos__(self, /) | +self | | __pow__(self, value, mod=None, /) | Return pow(self, value, mod). | | __radd__(self, value, /) | Return value+self. | | __rand__(self, value, /) | Return value&self. | | __rdivmod__(self, value, /) | Return divmod(value, self). | | __repr__(self, /) | Return repr(self). | | __rfloordiv__(self, value, /) | Return value//self. | | __rlshift__(self, value, /) | Return value<<self. | | __rmod__(self, value, /) | Return value%self. | | __rmul__(self, value, /) | Return value*self. | | __ror__(self, value, /) | Return value|self. | | __rpow__(self, value, mod=None, /) | Return pow(value, self, mod). | | __rrshift__(self, value, /) | Return value>>self. | | __rshift__(self, value, /) | Return self>>value. | | __rsub__(self, value, /) | Return value-self. | | __rtruediv__(self, value, /) | Return value/self. | | __rxor__(self, value, /) | Return value^self. | | __str__(self, /) | Return str(self). | | __sub__(self, value, /) | Return self-value. | | __truediv__(self, value, /) | Return self/value. | | __xor__(self, value, /) | Return self^value. | | ---------------------------------------------------------------------- | Static methods defined here: | | __new__(*args, **kwargs) from builtins.type | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Methods inherited from integer: | | __round__(...) | | ---------------------------------------------------------------------- | Data descriptors inherited from integer: | | denominator | denominator of value (1) | | numerator | numerator of value (the value itself) | | ---------------------------------------------------------------------- | Methods inherited from generic: | | __array__(...) | sc.__array__(dtype) return 0-dim array from scalar with specified dtype | | __array_wrap__(...) | sc.__array_wrap__(obj) return scalar from array | | __copy__(...) | | __deepcopy__(...) | | __format__(...) | NumPy array scalar formatter | | __getitem__(self, key, /) | Return self[key]. | | __reduce__(...) | Helper for pickle. | | __setstate__(...) | | __sizeof__(...) | Size of object in memory, in bytes. | | all(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | getfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | base | base object | | data | pointer to start of data | | dtype | get array data-descriptor | | flags | integer value of flags | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension uintp = class uint64(unsignedinteger) | Unsigned integer type, compatible with C ``unsigned long``. | Character code: ``'L'``. | Canonical name: ``np.uint``. | Alias *on this platform*: ``np.uint64``: 64-bit unsigned integer (0 to 18446744073709551615). | Alias *on this platform*: ``np.uintp``: Unsigned integer large enough to fit pointer, compatible with C ``uintptr_t``. | | Method resolution order: | uint64 | unsignedinteger | integer | number | generic | builtins.object | | Methods defined here: | | __abs__(self, /) | abs(self) | | __add__(self, value, /) | Return self+value. | | __and__(self, value, /) | Return self&value. | | __bool__(self, /) | self != 0 | | __divmod__(self, value, /) | Return divmod(self, value). | | __eq__(self, value, /) | Return self==value. | | __float__(self, /) | float(self) | | __floordiv__(self, value, /) | Return self//value. | | __ge__(self, value, /) | Return self>=value. | | __gt__(self, value, /) | Return self>value. | | __hash__(self, /) | Return hash(self). | | __index__(self, /) | Return self converted to an integer, if self is suitable for use as an index into a list. | | __int__(self, /) | int(self) | | __invert__(self, /) | ~self | | __le__(self, value, /) | Return self<=value. | | __lshift__(self, value, /) | Return self<<value. | | __lt__(self, value, /) | Return self<value. | | __mod__(self, value, /) | Return self%value. | | __mul__(self, value, /) | Return self*value. | | __ne__(self, value, /) | Return self!=value. | | __neg__(self, /) | -self | | __or__(self, value, /) | Return self|value. | | __pos__(self, /) | +self | | __pow__(self, value, mod=None, /) | Return pow(self, value, mod). | | __radd__(self, value, /) | Return value+self. | | __rand__(self, value, /) | Return value&self. | | __rdivmod__(self, value, /) | Return divmod(value, self). | | __repr__(self, /) | Return repr(self). | | __rfloordiv__(self, value, /) | Return value//self. | | __rlshift__(self, value, /) | Return value<<self. | | __rmod__(self, value, /) | Return value%self. | | __rmul__(self, value, /) | Return value*self. | | __ror__(self, value, /) | Return value|self. | | __rpow__(self, value, mod=None, /) | Return pow(value, self, mod). | | __rrshift__(self, value, /) | Return value>>self. | | __rshift__(self, value, /) | Return self>>value. | | __rsub__(self, value, /) | Return value-self. | | __rtruediv__(self, value, /) | Return value/self. | | __rxor__(self, value, /) | Return value^self. | | __str__(self, /) | Return str(self). | | __sub__(self, value, /) | Return self-value. | | __truediv__(self, value, /) | Return self/value. | | __xor__(self, value, /) | Return self^value. | | ---------------------------------------------------------------------- | Static methods defined here: | | __new__(*args, **kwargs) from builtins.type | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Methods inherited from integer: | | __round__(...) | | ---------------------------------------------------------------------- | Data descriptors inherited from integer: | | denominator | denominator of value (1) | | numerator | numerator of value (the value itself) | | ---------------------------------------------------------------------- | Methods inherited from generic: | | __array__(...) | sc.__array__(dtype) return 0-dim array from scalar with specified dtype | | __array_wrap__(...) | sc.__array_wrap__(obj) return scalar from array | | __copy__(...) | | __deepcopy__(...) | | __format__(...) | NumPy array scalar formatter | | __getitem__(self, key, /) | Return self[key]. | | __reduce__(...) | Helper for pickle. | | __setstate__(...) | | __sizeof__(...) | Size of object in memory, in bytes. | | all(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | getfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | base | base object | | data | pointer to start of data | | dtype | get array data-descriptor | | flags | integer value of flags | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension class ulonglong(unsignedinteger) | Signed integer type, compatible with C ``unsigned long long``. | Character code: ``'Q'``. | | Method resolution order: | ulonglong | unsignedinteger | integer | number | generic | builtins.object | | Methods defined here: | | __abs__(self, /) | abs(self) | | __add__(self, value, /) | Return self+value. | | __and__(self, value, /) | Return self&value. | | __bool__(self, /) | self != 0 | | __divmod__(self, value, /) | Return divmod(self, value). | | __eq__(self, value, /) | Return self==value. | | __float__(self, /) | float(self) | | __floordiv__(self, value, /) | Return self//value. | | __ge__(self, value, /) | Return self>=value. | | __gt__(self, value, /) | Return self>value. | | __hash__(self, /) | Return hash(self). | | __index__(self, /) | Return self converted to an integer, if self is suitable for use as an index into a list. | | __int__(self, /) | int(self) | | __invert__(self, /) | ~self | | __le__(self, value, /) | Return self<=value. | | __lshift__(self, value, /) | Return self<<value. | | __lt__(self, value, /) | Return self<value. | | __mod__(self, value, /) | Return self%value. | | __mul__(self, value, /) | Return self*value. | | __ne__(self, value, /) | Return self!=value. | | __neg__(self, /) | -self | | __or__(self, value, /) | Return self|value. | | __pos__(self, /) | +self | | __pow__(self, value, mod=None, /) | Return pow(self, value, mod). | | __radd__(self, value, /) | Return value+self. | | __rand__(self, value, /) | Return value&self. | | __rdivmod__(self, value, /) | Return divmod(value, self). | | __repr__(self, /) | Return repr(self). | | __rfloordiv__(self, value, /) | Return value//self. | | __rlshift__(self, value, /) | Return value<<self. | | __rmod__(self, value, /) | Return value%self. | | __rmul__(self, value, /) | Return value*self. | | __ror__(self, value, /) | Return value|self. | | __rpow__(self, value, mod=None, /) | Return pow(value, self, mod). | | __rrshift__(self, value, /) | Return value>>self. | | __rshift__(self, value, /) | Return self>>value. | | __rsub__(self, value, /) | Return value-self. | | __rtruediv__(self, value, /) | Return value/self. | | __rxor__(self, value, /) | Return value^self. | | __str__(self, /) | Return str(self). | | __sub__(self, value, /) | Return self-value. | | __truediv__(self, value, /) | Return self/value. | | __xor__(self, value, /) | Return self^value. | | ---------------------------------------------------------------------- | Static methods defined here: | | __new__(*args, **kwargs) from builtins.type | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Methods inherited from integer: | | __round__(...) | | ---------------------------------------------------------------------- | Data descriptors inherited from integer: | | denominator | denominator of value (1) | | numerator | numerator of value (the value itself) | | ---------------------------------------------------------------------- | Methods inherited from generic: | | __array__(...) | sc.__array__(dtype) return 0-dim array from scalar with specified dtype | | __array_wrap__(...) | sc.__array_wrap__(obj) return scalar from array | | __copy__(...) | | __deepcopy__(...) | | __format__(...) | NumPy array scalar formatter | | __getitem__(self, key, /) | Return self[key]. | | __reduce__(...) | Helper for pickle. | | __setstate__(...) | | __sizeof__(...) | Size of object in memory, in bytes. | | all(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | getfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | base | base object | | data | pointer to start of data | | dtype | get array data-descriptor | | flags | integer value of flags | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension unicode_ = class str_(builtins.str, character) | str(object='') -> str | str(bytes_or_buffer[, encoding[, errors]]) -> str | | Create a new string object from the given object. If encoding or | errors is specified, then the object must expose a data buffer | that will be decoded using the given encoding and error handler. | Otherwise, returns the result of object.__str__() (if defined) | or repr(object). | encoding defaults to sys.getdefaultencoding(). | errors defaults to 'strict'. | | Method resolution order: | str_ | builtins.str | character | flexible | generic | builtins.object | | Methods defined here: | | __eq__(self, value, /) | Return self==value. | | __ge__(self, value, /) | Return self>=value. | | __gt__(self, value, /) | Return self>value. | | __hash__(self, /) | Return hash(self). | | __le__(self, value, /) | Return self<=value. | | __lt__(self, value, /) | Return self<value. | | __ne__(self, value, /) | Return self!=value. | | __repr__(self, /) | Return repr(self). | | __str__(self, /) | Return str(self). | | ---------------------------------------------------------------------- | Static methods defined here: | | __new__(*args, **kwargs) from builtins.type | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Methods inherited from builtins.str: | | __add__(self, value, /) | Return self+value. | | __contains__(self, key, /) | Return key in self. | | __format__(self, format_spec, /) | Return a formatted version of the string as described by format_spec. | | __getattribute__(self, name, /) | Return getattr(self, name). | | __getitem__(self, key, /) | Return self[key]. | | __getnewargs__(...) | | __iter__(self, /) | Implement iter(self). | | __len__(self, /) | Return len(self). | | __mod__(self, value, /) | Return self%value. | | __mul__(self, value, /) | Return self*value. | | __rmod__(self, value, /) | Return value%self. | | __rmul__(self, value, /) | Return value*self. | | __sizeof__(self, /) | Return the size of the string in memory, in bytes. | | capitalize(self, /) | Return a capitalized version of the string. | | More specifically, make the first character have upper case and the rest lower | case. | | casefold(self, /) | Return a version of the string suitable for caseless comparisons. | | center(self, width, fillchar=' ', /) | Return a centered 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. | | encode(self, /, encoding='utf-8', errors='strict') | Encode the string using the codec registered for encoding. | | encoding | The encoding in which to encode the string. | errors | The error handling scheme to use for encoding errors. | The default is 'strict' meaning that encoding errors raise a | UnicodeEncodeError. Other possible values are 'ignore', 'replace' and | 'xmlcharrefreplace' as well as any other name registered with | codecs.register_error that can handle UnicodeEncodeErrors. | | endswith(...) | S.endswith(suffix[, start[, end]]) -> bool | | Return True if S ends with the specified suffix, False otherwise. | With optional start, test S beginning at that position. | With optional end, stop comparing S at that position. | suffix can also be a tuple of strings to try. | | expandtabs(self, /, tabsize=8) | Return a copy 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) -> str | | Return a formatted version of S, using substitutions from args and kwargs. | The substitutions are identified by braces ('{' and '}'). | | format_map(...) | S.format_map(mapping) -> str | | Return a formatted version of S, using substitutions from mapping. | The substitutions are identified by braces ('{' and '}'). | | index(...) | S.index(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. | | Raises ValueError when the substring is not found. | | isalnum(self, /) | Return True if the string is an alpha-numeric string, False otherwise. | | A string is alpha-numeric if all characters in the string are alpha-numeric and | there is at least one character in the string. | | isalpha(self, /) | Return True if the string is an alphabetic string, False otherwise. | | A string is alphabetic if all characters in the string are alphabetic and there | is at least one character in the string. | | isascii(self, /) | Return True if all characters in the string are ASCII, False otherwise. | | ASCII characters have code points in the range U+0000-U+007F. | Empty string is ASCII too. | | isdecimal(self, /) | Return True if the string is a decimal string, False otherwise. | | A string is a decimal string if all characters in the string are decimal and | there is at least one character in the string. | | isdigit(self, /) | Return True if the string is a digit string, False otherwise. | | A string is a digit string if all characters in the string are digits and there | is at least one character in the string. | | isidentifier(self, /) | Return True if the string is a valid Python identifier, False otherwise. | | Call keyword.iskeyword(s) to test whether string s is a reserved identifier, | such as "def" or "class". | | islower(self, /) | Return True if the string is a lowercase string, False otherwise. | | A string is lowercase if all cased characters in the string are lowercase and | there is at least one cased character in the string. | | isnumeric(self, /) | Return True if the string is a numeric string, False otherwise. | | A string is numeric if all characters in the string are numeric and there is at | least one character in the string. | | isprintable(self, /) | Return True if the string is printable, False otherwise. | | A string is printable if all of its characters are considered printable in | repr() or if it is empty. | | isspace(self, /) | Return True if the string is a whitespace string, False otherwise. | | A string is whitespace if all characters in the string are whitespace and there | is at least one character in the string. | | istitle(self, /) | Return True if the string is a title-cased string, False otherwise. | | In a title-cased string, upper- and title-case characters may only | follow uncased characters and lowercase characters only cased ones. | | isupper(self, /) | Return True if the string is an uppercase string, False otherwise. | | A string is uppercase if all cased characters in the string are uppercase and | there is at least one cased character in the string. | | join(self, iterable, /) | Concatenate any number of strings. | | The string whose method is called is inserted in between each given string. | The result is returned as a new string. | | Example: '.'.join(['ab', 'pq', 'rs']) -> 'ab.pq.rs' | | ljust(self, width, fillchar=' ', /) | Return a left-justified string of length width. | | Padding is done using the specified fill character (default is a space). | | lower(self, /) | Return a copy of the string converted to lowercase. | | lstrip(self, chars=None, /) | Return a copy of the string with leading whitespace removed. | | If chars is given and not None, remove characters in chars instead. | | partition(self, sep, /) | Partition the string into three parts using the given separator. | | This will search for the separator in the string. If the separator is found, | returns a 3-tuple containing the part before the separator, the separator | itself, and the part after it. | | If the separator is not found, returns a 3-tuple containing the original string | and two empty strings. | | replace(self, old, new, count=-1, /) | Return a copy with all occurrences of substring old replaced by new. | | count | Maximum number of occurrences to replace. | -1 (the default value) means replace all occurrences. | | 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 | | 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. | | Raises ValueError when the substring is not found. | | rjust(self, width, fillchar=' ', /) | Return a right-justified string of length width. | | Padding is done using the specified fill character (default is a space). | | rpartition(self, sep, /) | Partition the string into three parts using the given separator. | | This will search for the separator in the string, starting at the end. If | the separator is found, returns a 3-tuple containing the part before the | separator, the separator itself, and the part after it. | | If the separator is not found, returns a 3-tuple containing two empty strings | and the original string. | | rsplit(self, /, sep=None, maxsplit=-1) | Return a list of the words in the string, using sep as the delimiter string. | | sep | The delimiter according which to split the string. | None (the default value) means split according to any whitespace, | and discard empty strings from the result. | maxsplit | Maximum number of splits to do. | -1 (the default value) means no limit. | | Splits are done starting at the end of the string and working to the front. | | rstrip(self, chars=None, /) | Return a copy of the string with trailing whitespace removed. | | If chars is given and not None, remove characters in chars instead. | | split(self, /, sep=None, maxsplit=-1) | Return a list of the words in the string, using sep as the delimiter string. | | sep | The delimiter according which to split the string. | None (the default value) means split according to any whitespace, | and discard empty strings from the result. | maxsplit | Maximum number of splits to do. | -1 (the default value) means no limit. | | splitlines(self, /, keepends=False) | Return a list of the lines in the string, 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(self, chars=None, /) | Return a copy of the string with leading and trailing whitespace removed. | | If chars is given and not None, remove characters in chars instead. | | swapcase(self, /) | Convert uppercase characters to lowercase and lowercase characters to uppercase. | | title(self, /) | Return a version of the string where each word is titlecased. | | More specifically, words start with uppercased characters and all remaining | cased characters have lower case. | | translate(self, table, /) | Replace each character in the string using the given translation table. | | table | Translation table, which must be a mapping of Unicode ordinals to | Unicode ordinals, strings, or None. | | The table must implement lookup/indexing via __getitem__, for instance a | dictionary or list. If this operation raises LookupError, the character is | left untouched. Characters mapped to None are deleted. | | upper(self, /) | Return a copy of the string converted to uppercase. | | zfill(self, width, /) | Pad a numeric string with zeros on the left, to fill a field of the given width. | | The string is never truncated. | | ---------------------------------------------------------------------- | Static methods inherited from builtins.str: | | maketrans(...) | Return a translation table usable for str.translate(). | | If there is only one argument, it must be a dictionary mapping Unicode | ordinals (integers) or characters to Unicode ordinals, strings or None. | Character keys will be then converted to ordinals. | If there are two arguments, they must be strings of equal length, and | in the resulting dictionary, each character in x will be mapped to the | character at the same position in y. If there is a third argument, it | must be a string, whose characters will be mapped to None in the result. | | ---------------------------------------------------------------------- | Methods inherited from generic: | | __abs__(self, /) | abs(self) | | __and__(self, value, /) | Return self&value. | | __array__(...) | sc.__array__(dtype) return 0-dim array from scalar with specified dtype | | __array_wrap__(...) | sc.__array_wrap__(obj) return scalar from array | | __bool__(self, /) | self != 0 | | __copy__(...) | | __deepcopy__(...) | | __divmod__(self, value, /) | Return divmod(self, value). | | __float__(self, /) | float(self) | | __floordiv__(self, value, /) | Return self//value. | | __int__(self, /) | int(self) | | __invert__(self, /) | ~self | | __lshift__(self, value, /) | Return self<<value. | | __neg__(self, /) | -self | | __or__(self, value, /) | Return self|value. | | __pos__(self, /) | +self | | __pow__(self, value, mod=None, /) | Return pow(self, value, mod). | | __radd__(self, value, /) | Return value+self. | | __rand__(self, value, /) | Return value&self. | | __rdivmod__(self, value, /) | Return divmod(value, self). | | __reduce__(...) | Helper for pickle. | | __rfloordiv__(self, value, /) | Return value//self. | | __rlshift__(self, value, /) | Return value<<self. | | __ror__(self, value, /) | Return value|self. | | __rpow__(self, value, mod=None, /) | Return pow(value, self, mod). | | __rrshift__(self, value, /) | Return value>>self. | | __rshift__(self, value, /) | Return self>>value. | | __rsub__(self, value, /) | Return value-self. | | __rtruediv__(self, value, /) | Return value/self. | | __rxor__(self, value, /) | Return value^self. | | __setstate__(...) | | __sub__(self, value, /) | Return self-value. | | __truediv__(self, value, /) | Return self/value. | | __xor__(self, value, /) | Return self^value. | | all(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | getfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | base | base object | | data | pointer to start of data | | dtype | get array data-descriptor | | flags | integer value of flags | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension class unsignedinteger(integer) | Abstract base class of all unsigned integer scalar types. | | Method resolution order: | unsignedinteger | integer | number | generic | builtins.object | | Methods inherited from integer: | | __round__(...) | | ---------------------------------------------------------------------- | Data descriptors inherited from integer: | | denominator | denominator of value (1) | | numerator | numerator of value (the value itself) | | ---------------------------------------------------------------------- | Methods inherited from generic: | | __abs__(self, /) | abs(self) | | __add__(self, value, /) | Return self+value. | | __and__(self, value, /) | Return self&value. | | __array__(...) | sc.__array__(dtype) return 0-dim array from scalar with specified dtype | | __array_wrap__(...) | sc.__array_wrap__(obj) return scalar from array | | __bool__(self, /) | self != 0 | | __copy__(...) | | __deepcopy__(...) | | __divmod__(self, value, /) | Return divmod(self, value). | | __eq__(self, value, /) | Return self==value. | | __float__(self, /) | float(self) | | __floordiv__(self, value, /) | Return self//value. | | __format__(...) | NumPy array scalar formatter | | __ge__(self, value, /) | Return self>=value. | | __getitem__(self, key, /) | Return self[key]. | | __gt__(self, value, /) | Return self>value. | | __int__(self, /) | int(self) | | __invert__(self, /) | ~self | | __le__(self, value, /) | Return self<=value. | | __lshift__(self, value, /) | Return self<<value. | | __lt__(self, value, /) | Return self<value. | | __mod__(self, value, /) | Return self%value. | | __mul__(self, value, /) | Return self*value. | | __ne__(self, value, /) | Return self!=value. | | __neg__(self, /) | -self | | __or__(self, value, /) | Return self|value. | | __pos__(self, /) | +self | | __pow__(self, value, mod=None, /) | Return pow(self, value, mod). | | __radd__(self, value, /) | Return value+self. | | __rand__(self, value, /) | Return value&self. | | __rdivmod__(self, value, /) | Return divmod(value, self). | | __reduce__(...) | Helper for pickle. | | __rfloordiv__(self, value, /) | Return value//self. | | __rlshift__(self, value, /) | Return value<<self. | | __rmod__(self, value, /) | Return value%self. | | __rmul__(self, value, /) | Return value*self. | | __ror__(self, value, /) | Return value|self. | | __rpow__(self, value, mod=None, /) | Return pow(value, self, mod). | | __rrshift__(self, value, /) | Return value>>self. | | __rshift__(self, value, /) | Return self>>value. | | __rsub__(self, value, /) | Return value-self. | | __rtruediv__(self, value, /) | Return value/self. | | __rxor__(self, value, /) | Return value^self. | | __setstate__(...) | | __sizeof__(...) | Size of object in memory, in bytes. | | __sub__(self, value, /) | Return self-value. | | __truediv__(self, value, /) | Return self/value. | | __xor__(self, value, /) | Return self^value. | | all(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | getfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | base | base object | | data | pointer to start of data | | dtype | get array data-descriptor | | flags | integer value of flags | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension | | ---------------------------------------------------------------------- | Data and other attributes inherited from generic: | | __hash__ = None ushort = class uint16(unsignedinteger) | Unsigned integer type, compatible with C ``unsigned short``. | Character code: ``'H'``. | Canonical name: ``np.ushort``. | Alias *on this platform*: ``np.uint16``: 16-bit unsigned integer (0 to 65535). | | Method resolution order: | uint16 | unsignedinteger | integer | number | generic | builtins.object | | Methods defined here: | | __abs__(self, /) | abs(self) | | __add__(self, value, /) | Return self+value. | | __and__(self, value, /) | Return self&value. | | __bool__(self, /) | self != 0 | | __divmod__(self, value, /) | Return divmod(self, value). | | __eq__(self, value, /) | Return self==value. | | __float__(self, /) | float(self) | | __floordiv__(self, value, /) | Return self//value. | | __ge__(self, value, /) | Return self>=value. | | __gt__(self, value, /) | Return self>value. | | __hash__(self, /) | Return hash(self). | | __index__(self, /) | Return self converted to an integer, if self is suitable for use as an index into a list. | | __int__(self, /) | int(self) | | __invert__(self, /) | ~self | | __le__(self, value, /) | Return self<=value. | | __lshift__(self, value, /) | Return self<<value. | | __lt__(self, value, /) | Return self<value. | | __mod__(self, value, /) | Return self%value. | | __mul__(self, value, /) | Return self*value. | | __ne__(self, value, /) | Return self!=value. | | __neg__(self, /) | -self | | __or__(self, value, /) | Return self|value. | | __pos__(self, /) | +self | | __pow__(self, value, mod=None, /) | Return pow(self, value, mod). | | __radd__(self, value, /) | Return value+self. | | __rand__(self, value, /) | Return value&self. | | __rdivmod__(self, value, /) | Return divmod(value, self). | | __repr__(self, /) | Return repr(self). | | __rfloordiv__(self, value, /) | Return value//self. | | __rlshift__(self, value, /) | Return value<<self. | | __rmod__(self, value, /) | Return value%self. | | __rmul__(self, value, /) | Return value*self. | | __ror__(self, value, /) | Return value|self. | | __rpow__(self, value, mod=None, /) | Return pow(value, self, mod). | | __rrshift__(self, value, /) | Return value>>self. | | __rshift__(self, value, /) | Return self>>value. | | __rsub__(self, value, /) | Return value-self. | | __rtruediv__(self, value, /) | Return value/self. | | __rxor__(self, value, /) | Return value^self. | | __str__(self, /) | Return str(self). | | __sub__(self, value, /) | Return self-value. | | __truediv__(self, value, /) | Return self/value. | | __xor__(self, value, /) | Return self^value. | | ---------------------------------------------------------------------- | Static methods defined here: | | __new__(*args, **kwargs) from builtins.type | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Methods inherited from integer: | | __round__(...) | | ---------------------------------------------------------------------- | Data descriptors inherited from integer: | | denominator | denominator of value (1) | | numerator | numerator of value (the value itself) | | ---------------------------------------------------------------------- | Methods inherited from generic: | | __array__(...) | sc.__array__(dtype) return 0-dim array from scalar with specified dtype | | __array_wrap__(...) | sc.__array_wrap__(obj) return scalar from array | | __copy__(...) | | __deepcopy__(...) | | __format__(...) | NumPy array scalar formatter | | __getitem__(self, key, /) | Return self[key]. | | __reduce__(...) | Helper for pickle. | | __setstate__(...) | | __sizeof__(...) | Size of object in memory, in bytes. | | all(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | getfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setfield(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | base | base object | | data | pointer to start of data | | dtype | get array data-descriptor | | flags | integer value of flags | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension class vectorize(builtins.object) | vectorize(pyfunc, otypes=None, doc=None, excluded=None, cache=False, signature=None) | | vectorize(pyfunc, otypes=None, doc=None, excluded=None, cache=False, | signature=None) | | Generalized function class. | | Define a vectorized function which takes a nested sequence of objects or | numpy arrays as inputs and returns a single numpy array or a tuple of numpy | arrays. The vectorized function evaluates `pyfunc` over successive tuples | of the input arrays like the python map function, except it uses the | broadcasting rules of numpy. | | The data type of the output of `vectorized` is determined by calling | the function with the first element of the input. This can be avoided | by specifying the `otypes` argument. | | Parameters | ---------- | pyfunc : callable | A python function or method. | otypes : str or list of dtypes, optional | The output data type. It must be specified as either a string of | typecode characters or a list of data type specifiers. There should | be one data type specifier for each output. | doc : str, optional | The docstring for the function. If None, the docstring will be the | ``pyfunc.__doc__``. | excluded : set, optional | Set of strings or integers representing the positional or keyword | arguments for which the function will not be vectorized. These will be | passed directly to `pyfunc` unmodified. | | .. versionadded:: 1.7.0 | | cache : bool, optional | If `True`, then cache the first function call that determines the number | of outputs if `otypes` is not provided. | | .. versionadded:: 1.7.0 | | signature : string, optional | Generalized universal function signature, e.g., ``(m,n),(n)->(m)`` for | vectorized matrix-vector multiplication. If provided, ``pyfunc`` will | be called with (and expected to return) arrays with shapes given by the | size of corresponding core dimensions. By default, ``pyfunc`` is | assumed to take scalars as input and output. | | .. versionadded:: 1.12.0 | | Returns | ------- | vectorized : callable | Vectorized function. | | See Also | -------- | frompyfunc : Takes an arbitrary Python function and returns a ufunc | | Notes | ----- | The `vectorize` function is provided primarily for convenience, not for | performance. The implementation is essentially a for loop. | | If `otypes` is not specified, then a call to the function with the | first argument will be used to determine the number of outputs. The | results of this call will be cached if `cache` is `True` to prevent | calling the function twice. However, to implement the cache, the | original function must be wrapped which will slow down subsequent | calls, so only do this if your function is expensive. | | The new keyword argument interface and `excluded` argument support | further degrades performance. | | References | ---------- | .. [1] NumPy Reference, section `Generalized Universal Function API | <https://docs.scipy.org/doc/numpy/reference/c-api.generalized-ufuncs.html>`_. | | Examples | -------- | >>> def myfunc(a, b): | ... "Return a-b if a>b, otherwise return a+b" | ... if a > b: | ... return a - b | ... else: | ... return a + b | | >>> vfunc = np.vectorize(myfunc) | >>> vfunc([1, 2, 3, 4], 2) | array([3, 4, 1, 2]) | | The docstring is taken from the input function to `vectorize` unless it | is specified: | | >>> vfunc.__doc__ | 'Return a-b if a>b, otherwise return a+b' | >>> vfunc = np.vectorize(myfunc, doc='Vectorized `myfunc`') | >>> vfunc.__doc__ | 'Vectorized `myfunc`' | | The output type is determined by evaluating the first element of the input, | unless it is specified: | | >>> out = vfunc([1, 2, 3, 4], 2) | >>> type(out[0]) | <class 'numpy.int64'> | >>> vfunc = np.vectorize(myfunc, otypes=[float]) | >>> out = vfunc([1, 2, 3, 4], 2) | >>> type(out[0]) | <class 'numpy.float64'> | | The `excluded` argument can be used to prevent vectorizing over certain | arguments. This can be useful for array-like arguments of a fixed length | such as the coefficients for a polynomial as in `polyval`: | | >>> def mypolyval(p, x): | ... _p = list(p) | ... res = _p.pop(0) | ... while _p: | ... res = res*x + _p.pop(0) | ... return res | >>> vpolyval = np.vectorize(mypolyval, excluded=['p']) | >>> vpolyval(p=[1, 2, 3], x=[0, 1]) | array([3, 6]) | | Positional arguments may also be excluded by specifying their position: | | >>> vpolyval.excluded.add(0) | >>> vpolyval([1, 2, 3], x=[0, 1]) | array([3, 6]) | | The `signature` argument allows for vectorizing functions that act on | non-scalar arrays of fixed length. For example, you can use it for a | vectorized calculation of Pearson correlation coefficient and its p-value: | | >>> import scipy.stats | >>> pearsonr = np.vectorize(scipy.stats.pearsonr, | ... signature='(n),(n)->(),()') | >>> pearsonr([[0, 1, 2, 3]], [[1, 2, 3, 4], [4, 3, 2, 1]]) | (array([ 1., -1.]), array([ 0., 0.])) | | Or for a vectorized convolution: | | >>> convolve = np.vectorize(np.convolve, signature='(n),(m)->(k)') | >>> convolve(np.eye(4), [1, 2, 1]) | array([[1., 2., 1., 0., 0., 0.], | [0., 1., 2., 1., 0., 0.], | [0., 0., 1., 2., 1., 0.], | [0., 0., 0., 1., 2., 1.]]) | | Methods defined here: | | __call__(self, *args, **kwargs) | Return arrays with the results of `pyfunc` broadcast (vectorized) over | `args` and `kwargs` not in `excluded`. | | __init__(self, pyfunc, otypes=None, doc=None, excluded=None, cache=False, signature=None) | Initialize self. See help(type(self)) for accurate signature. | | ---------------------------------------------------------------------- | Data descriptors defined here: | | __dict__ | dictionary for instance variables (if defined) | | __weakref__ | list of weak references to the object (if defined) class void(flexible) | Abstract base class of all scalar types without predefined length. | The actual size of these types depends on the specific `np.dtype` | instantiation. | | Method resolution order: | void | flexible | generic | builtins.object | | Methods defined here: | | __delitem__(self, key, /) | Delete self[key]. | | __eq__(self, value, /) | Return self==value. | | __ge__(self, value, /) | Return self>=value. | | __getitem__(self, key, /) | Return self[key]. | | __gt__(self, value, /) | Return self>value. | | __hash__(self, /) | Return hash(self). | | __le__(self, value, /) | Return self<=value. | | __len__(self, /) | Return len(self). | | __lt__(self, value, /) | Return self<value. | | __ne__(self, value, /) | Return self!=value. | | __repr__(self, /) | Return repr(self). | | __setitem__(self, key, value, /) | Set self[key] to value. | | __str__(self, /) | Return str(self). | | 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. | | 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. | | ---------------------------------------------------------------------- | Static methods defined here: | | __new__(*args, **kwargs) from builtins.type | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Data descriptors defined here: | | base | base object | | dtype | dtype object | | flags | integer value of flags | | ---------------------------------------------------------------------- | Methods inherited from generic: | | __abs__(self, /) | abs(self) | | __add__(self, value, /) | Return self+value. | | __and__(self, value, /) | Return self&value. | | __array__(...) | sc.__array__(dtype) return 0-dim array from scalar with specified dtype | | __array_wrap__(...) | sc.__array_wrap__(obj) return scalar from array | | __bool__(self, /) | self != 0 | | __copy__(...) | | __deepcopy__(...) | | __divmod__(self, value, /) | Return divmod(self, value). | | __float__(self, /) | float(self) | | __floordiv__(self, value, /) | Return self//value. | | __format__(...) | NumPy array scalar formatter | | __int__(self, /) | int(self) | | __invert__(self, /) | ~self | | __lshift__(self, value, /) | Return self<<value. | | __mod__(self, value, /) | Return self%value. | | __mul__(self, value, /) | Return self*value. | | __neg__(self, /) | -self | | __or__(self, value, /) | Return self|value. | | __pos__(self, /) | +self | | __pow__(self, value, mod=None, /) | Return pow(self, value, mod). | | __radd__(self, value, /) | Return value+self. | | __rand__(self, value, /) | Return value&self. | | __rdivmod__(self, value, /) | Return divmod(value, self). | | __reduce__(...) | Helper for pickle. | | __rfloordiv__(self, value, /) | Return value//self. | | __rlshift__(self, value, /) | Return value<<self. | | __rmod__(self, value, /) | Return value%self. | | __rmul__(self, value, /) | Return value*self. | | __ror__(self, value, /) | Return value|self. | | __rpow__(self, value, mod=None, /) | Return pow(value, self, mod). | | __rrshift__(self, value, /) | Return value>>self. | | __rshift__(self, value, /) | Return self>>value. | | __rsub__(self, value, /) | Return value-self. | | __rtruediv__(self, value, /) | Return value/self. | | __rxor__(self, value, /) | Return value^self. | | __setstate__(...) | | __sizeof__(...) | Size of object in memory, in bytes. | | __sub__(self, value, /) | Return self-value. | | __truediv__(self, value, /) | Return self/value. | | __xor__(self, value, /) | Return self^value. | | all(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | data | pointer to start of data | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension void0 = class void(flexible) | Abstract base class of all scalar types without predefined length. | The actual size of these types depends on the specific `np.dtype` | instantiation. | | Method resolution order: | void | flexible | generic | builtins.object | | Methods defined here: | | __delitem__(self, key, /) | Delete self[key]. | | __eq__(self, value, /) | Return self==value. | | __ge__(self, value, /) | Return self>=value. | | __getitem__(self, key, /) | Return self[key]. | | __gt__(self, value, /) | Return self>value. | | __hash__(self, /) | Return hash(self). | | __le__(self, value, /) | Return self<=value. | | __len__(self, /) | Return len(self). | | __lt__(self, value, /) | Return self<value. | | __ne__(self, value, /) | Return self!=value. | | __repr__(self, /) | Return repr(self). | | __setitem__(self, key, value, /) | Set self[key] to value. | | __str__(self, /) | Return str(self). | | 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. | | 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. | | ---------------------------------------------------------------------- | Static methods defined here: | | __new__(*args, **kwargs) from builtins.type | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Data descriptors defined here: | | base | base object | | dtype | dtype object | | flags | integer value of flags | | ---------------------------------------------------------------------- | Methods inherited from generic: | | __abs__(self, /) | abs(self) | | __add__(self, value, /) | Return self+value. | | __and__(self, value, /) | Return self&value. | | __array__(...) | sc.__array__(dtype) return 0-dim array from scalar with specified dtype | | __array_wrap__(...) | sc.__array_wrap__(obj) return scalar from array | | __bool__(self, /) | self != 0 | | __copy__(...) | | __deepcopy__(...) | | __divmod__(self, value, /) | Return divmod(self, value). | | __float__(self, /) | float(self) | | __floordiv__(self, value, /) | Return self//value. | | __format__(...) | NumPy array scalar formatter | | __int__(self, /) | int(self) | | __invert__(self, /) | ~self | | __lshift__(self, value, /) | Return self<<value. | | __mod__(self, value, /) | Return self%value. | | __mul__(self, value, /) | Return self*value. | | __neg__(self, /) | -self | | __or__(self, value, /) | Return self|value. | | __pos__(self, /) | +self | | __pow__(self, value, mod=None, /) | Return pow(self, value, mod). | | __radd__(self, value, /) | Return value+self. | | __rand__(self, value, /) | Return value&self. | | __rdivmod__(self, value, /) | Return divmod(value, self). | | __reduce__(...) | Helper for pickle. | | __rfloordiv__(self, value, /) | Return value//self. | | __rlshift__(self, value, /) | Return value<<self. | | __rmod__(self, value, /) | Return value%self. | | __rmul__(self, value, /) | Return value*self. | | __ror__(self, value, /) | Return value|self. | | __rpow__(self, value, mod=None, /) | Return pow(value, self, mod). | | __rrshift__(self, value, /) | Return value>>self. | | __rshift__(self, value, /) | Return self>>value. | | __rsub__(self, value, /) | Return value-self. | | __rtruediv__(self, value, /) | Return value/self. | | __rxor__(self, value, /) | Return value^self. | | __setstate__(...) | | __sizeof__(...) | Size of object in memory, in bytes. | | __sub__(self, value, /) | Return self-value. | | __truediv__(self, value, /) | Return self/value. | | __xor__(self, value, /) | Return self^value. | | all(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | any(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmax(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argmin(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | argsort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | astype(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | byteswap(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | choose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | clip(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | compress(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | conj(...) | | conjugate(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | copy(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumprod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | cumsum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | diagonal(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dump(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | dumps(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | fill(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | flatten(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | item(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | itemset(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | max(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | mean(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | min(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | newbyteorder(...) | newbyteorder(new_order='S') | | Return a new `dtype` with a different byte order. | | Changes are also made in all fields and sub-arrays of the data type. | | The `new_order` code can be any from the following: | | * 'S' - swap dtype from current to opposite endian | * {'<', 'L'} - little endian | * {'>', 'B'} - big endian | * {'=', 'N'} - native order | * {'|', 'I'} - ignore (no change to byte order) | | Parameters | ---------- | new_order : str, optional | Byte order to force; a value from the byte order specifications | above. The default value ('S') results in swapping the current | byte order. The code does a case-insensitive check on the first | letter of `new_order` for the alternatives above. For example, | any of 'B' or 'b' or 'biggish' are valid to specify big-endian. | | | Returns | ------- | new_dtype : dtype | New `dtype` object with the given change to the byte order. | | nonzero(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | prod(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ptp(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | put(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ravel(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | repeat(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | reshape(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | resize(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | round(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | searchsorted(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | setflags(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class so as to | provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sort(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | squeeze(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | std(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | sum(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | swapaxes(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | take(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tobytes(...) | | tofile(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tolist(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | tostring(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | trace(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | transpose(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | var(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | view(...) | Not implemented (virtual attribute) | | Class generic exists solely to derive numpy scalars from, and possesses, | albeit unimplemented, all the attributes of the ndarray class | so as to provide a uniform API. | | See also the corresponding attribute of the derived class of interest. | | ---------------------------------------------------------------------- | Data descriptors inherited from generic: | | T | transpose | | __array_interface__ | Array protocol: Python side | | __array_priority__ | Array priority. | | __array_struct__ | Array protocol: struct | | data | pointer to start of data | | flat | a 1-d view of scalar | | imag | imaginary part of scalar | | itemsize | length of one element in bytes | | nbytes | length of item in bytes | | ndim | number of array dimensions | | real | real part of scalar | | shape | tuple of array dimensions | | size | number of elements in the gentype | | strides | tuple of bytes steps in each dimension FUNCTIONS _add_newdoc_ufunc(...) scipy._add_newdoc_ufunc is deprecated and will be removed in SciPy 2.0.0, use numpy._add_newdoc_ufunc instead absolute(...) scipy.absolute is deprecated and will be removed in SciPy 2.0.0, use numpy.absolute instead add(...) scipy.add is deprecated and will be removed in SciPy 2.0.0, use numpy.add instead add_docstring(...) scipy.add_docstring is deprecated and will be removed in SciPy 2.0.0, use numpy.add_docstring instead add_newdoc(place, obj, doc, warn_on_python=True) scipy.add_newdoc is deprecated and will be removed in SciPy 2.0.0, use numpy.add_newdoc instead add_newdoc_ufunc = _add_newdoc_ufunc(...) scipy.add_newdoc_ufunc is deprecated and will be removed in SciPy 2.0.0, use numpy.add_newdoc_ufunc instead alen(a) scipy.alen is deprecated and will be removed in SciPy 2.0.0, use numpy.alen instead all(a, axis=None, out=None, keepdims=<no value>) scipy.all is deprecated and will be removed in SciPy 2.0.0, use numpy.all instead allclose(a, b, rtol=1e-05, atol=1e-08, equal_nan=False) scipy.allclose is deprecated and will be removed in SciPy 2.0.0, use numpy.allclose instead alltrue(*args, **kwargs) scipy.alltrue is deprecated and will be removed in SciPy 2.0.0, use numpy.alltrue instead amax(a, axis=None, out=None, keepdims=<no value>, initial=<no value>, where=<no value>) scipy.amax is deprecated and will be removed in SciPy 2.0.0, use numpy.amax instead amin(a, axis=None, out=None, keepdims=<no value>, initial=<no value>, where=<no value>) scipy.amin is deprecated and will be removed in SciPy 2.0.0, use numpy.amin instead angle(z, deg=False) scipy.angle is deprecated and will be removed in SciPy 2.0.0, use numpy.angle instead any(a, axis=None, out=None, keepdims=<no value>) scipy.any is deprecated and will be removed in SciPy 2.0.0, use numpy.any instead append(arr, values, axis=None) scipy.append is deprecated and will be removed in SciPy 2.0.0, use numpy.append instead apply_along_axis(func1d, axis, arr, *args, **kwargs) scipy.apply_along_axis is deprecated and will be removed in SciPy 2.0.0, use numpy.apply_along_axis instead apply_over_axes(func, a, axes) scipy.apply_over_axes is deprecated and will be removed in SciPy 2.0.0, use numpy.apply_over_axes instead arange(...) scipy.arange is deprecated and will be removed in SciPy 2.0.0, use numpy.arange instead arccos(x) scipy.arccos is deprecated and will be removed in SciPy 2.0.0, use numpy.lib.scimath.arccos instead arccosh(...) scipy.arccosh is deprecated and will be removed in SciPy 2.0.0, use numpy.arccosh instead arcsin(x) scipy.arcsin is deprecated and will be removed in SciPy 2.0.0, use numpy.lib.scimath.arcsin instead arcsinh(...) scipy.arcsinh is deprecated and will be removed in SciPy 2.0.0, use numpy.arcsinh instead arctan(...) scipy.arctan is deprecated and will be removed in SciPy 2.0.0, use numpy.arctan instead arctan2(...) scipy.arctan2 is deprecated and will be removed in SciPy 2.0.0, use numpy.arctan2 instead arctanh(x) scipy.arctanh is deprecated and will be removed in SciPy 2.0.0, use numpy.lib.scimath.arctanh instead argmax(a, axis=None, out=None) scipy.argmax is deprecated and will be removed in SciPy 2.0.0, use numpy.argmax instead argmin(a, axis=None, out=None) scipy.argmin is deprecated and will be removed in SciPy 2.0.0, use numpy.argmin instead argpartition(a, kth, axis=-1, kind='introselect', order=None) scipy.argpartition is deprecated and will be removed in SciPy 2.0.0, use numpy.argpartition instead argsort(a, axis=-1, kind=None, order=None) scipy.argsort is deprecated and will be removed in SciPy 2.0.0, use numpy.argsort instead argwhere(a) scipy.argwhere is deprecated and will be removed in SciPy 2.0.0, use numpy.argwhere instead around(a, decimals=0, out=None) scipy.around is deprecated and will be removed in SciPy 2.0.0, use numpy.around instead array(...) scipy.array is deprecated and will be removed in SciPy 2.0.0, use numpy.array instead array2string(a, max_line_width=None, precision=None, suppress_small=None, separator=' ', prefix='', style=<no value>, formatter=None, threshold=None, edgeitems=None, sign=None, floatmode=None, suffix='', *, legacy=None) scipy.array2string is deprecated and will be removed in SciPy 2.0.0, use numpy.array2string instead array_equal(a1, a2, equal_nan=False) scipy.array_equal is deprecated and will be removed in SciPy 2.0.0, use numpy.array_equal instead array_equiv(a1, a2) scipy.array_equiv is deprecated and will be removed in SciPy 2.0.0, use numpy.array_equiv instead array_repr(arr, max_line_width=None, precision=None, suppress_small=None) scipy.array_repr is deprecated and will be removed in SciPy 2.0.0, use numpy.array_repr instead array_split(ary, indices_or_sections, axis=0) scipy.array_split is deprecated and will be removed in SciPy 2.0.0, use numpy.array_split instead array_str(a, max_line_width=None, precision=None, suppress_small=None) scipy.array_str is deprecated and will be removed in SciPy 2.0.0, use numpy.array_str instead asanyarray(a, dtype=None, order=None) scipy.asanyarray is deprecated and will be removed in SciPy 2.0.0, use numpy.asanyarray instead asarray(a, dtype=None, order=None) scipy.asarray is deprecated and will be removed in SciPy 2.0.0, use numpy.asarray instead asarray_chkfinite(a, dtype=None, order=None) scipy.asarray_chkfinite is deprecated and will be removed in SciPy 2.0.0, use numpy.asarray_chkfinite instead ascontiguousarray(a, dtype=None) scipy.ascontiguousarray is deprecated and will be removed in SciPy 2.0.0, use numpy.ascontiguousarray instead asfarray(a, dtype=<class 'numpy.float64'>) scipy.asfarray is deprecated and will be removed in SciPy 2.0.0, use numpy.asfarray instead asfortranarray(a, dtype=None) scipy.asfortranarray is deprecated and will be removed in SciPy 2.0.0, use numpy.asfortranarray instead asmatrix(data, dtype=None) scipy.asmatrix is deprecated and will be removed in SciPy 2.0.0, use numpy.asmatrix instead asscalar(a) scipy.asscalar is deprecated and will be removed in SciPy 2.0.0, use numpy.asscalar instead atleast_1d(*arys) scipy.atleast_1d is deprecated and will be removed in SciPy 2.0.0, use numpy.atleast_1d instead atleast_2d(*arys) scipy.atleast_2d is deprecated and will be removed in SciPy 2.0.0, use numpy.atleast_2d instead atleast_3d(*arys) scipy.atleast_3d is deprecated and will be removed in SciPy 2.0.0, use numpy.atleast_3d instead average(a, axis=None, weights=None, returned=False) scipy.average is deprecated and will be removed in SciPy 2.0.0, use numpy.average instead bartlett(M) scipy.bartlett is deprecated and will be removed in SciPy 2.0.0, use numpy.bartlett instead base_repr(number, base=2, padding=0) scipy.base_repr is deprecated and will be removed in SciPy 2.0.0, use numpy.base_repr instead binary_repr(num, width=None) scipy.binary_repr is deprecated and will be removed in SciPy 2.0.0, use numpy.binary_repr instead bincount(...) scipy.bincount is deprecated and will be removed in SciPy 2.0.0, use numpy.bincount instead bitwise_and(...) scipy.bitwise_and is deprecated and will be removed in SciPy 2.0.0, use numpy.bitwise_and instead bitwise_not = invert(...) scipy.bitwise_not is deprecated and will be removed in SciPy 2.0.0, use numpy.bitwise_not instead bitwise_or(...) scipy.bitwise_or is deprecated and will be removed in SciPy 2.0.0, use numpy.bitwise_or instead bitwise_xor(...) scipy.bitwise_xor is deprecated and will be removed in SciPy 2.0.0, use numpy.bitwise_xor instead blackman(M) scipy.blackman is deprecated and will be removed in SciPy 2.0.0, use numpy.blackman instead block(arrays) scipy.block is deprecated and will be removed in SciPy 2.0.0, use numpy.block instead bmat(obj, ldict=None, gdict=None) scipy.bmat is deprecated and will be removed in SciPy 2.0.0, use numpy.bmat instead broadcast_arrays(*args, subok=False) scipy.broadcast_arrays is deprecated and will be removed in SciPy 2.0.0, use numpy.broadcast_arrays instead broadcast_to(array, shape, subok=False) scipy.broadcast_to is deprecated and will be removed in SciPy 2.0.0, use numpy.broadcast_to instead busday_count(...) scipy.busday_count is deprecated and will be removed in SciPy 2.0.0, use numpy.busday_count instead busday_offset(...) scipy.busday_offset is deprecated and will be removed in SciPy 2.0.0, use numpy.busday_offset instead byte_bounds(a) scipy.byte_bounds is deprecated and will be removed in SciPy 2.0.0, use numpy.byte_bounds instead can_cast(...) scipy.can_cast is deprecated and will be removed in SciPy 2.0.0, use numpy.can_cast instead cbrt(...) scipy.cbrt is deprecated and will be removed in SciPy 2.0.0, use numpy.cbrt instead ceil(...) scipy.ceil is deprecated and will be removed in SciPy 2.0.0, use numpy.ceil instead choose(a, choices, out=None, mode='raise') scipy.choose is deprecated and will be removed in SciPy 2.0.0, use numpy.choose instead clip(a, a_min, a_max, out=None, **kwargs) scipy.clip is deprecated and will be removed in SciPy 2.0.0, use numpy.clip instead column_stack(tup) scipy.column_stack is deprecated and will be removed in SciPy 2.0.0, use numpy.column_stack instead common_type(*arrays) scipy.common_type is deprecated and will be removed in SciPy 2.0.0, use numpy.common_type instead compare_chararrays(...) scipy.compare_chararrays is deprecated and will be removed in SciPy 2.0.0, use numpy.compare_chararrays instead compress(condition, a, axis=None, out=None) scipy.compress is deprecated and will be removed in SciPy 2.0.0, use numpy.compress instead concatenate(...) scipy.concatenate is deprecated and will be removed in SciPy 2.0.0, use numpy.concatenate instead conj = conjugate(...) scipy.conj is deprecated and will be removed in SciPy 2.0.0, use numpy.conj instead conjugate(...) scipy.conjugate is deprecated and will be removed in SciPy 2.0.0, use numpy.conjugate instead convolve(a, v, mode='full') scipy.convolve is deprecated and will be removed in SciPy 2.0.0, use numpy.convolve instead copy(a, order='K', subok=False) scipy.copy is deprecated and will be removed in SciPy 2.0.0, use numpy.copy instead copysign(...) scipy.copysign is deprecated and will be removed in SciPy 2.0.0, use numpy.copysign instead copyto(...) scipy.copyto is deprecated and will be removed in SciPy 2.0.0, use numpy.copyto instead corrcoef(x, y=None, rowvar=True, bias=<no value>, ddof=<no value>) scipy.corrcoef is deprecated and will be removed in SciPy 2.0.0, use numpy.corrcoef instead correlate(a, v, mode='valid') scipy.correlate is deprecated and will be removed in SciPy 2.0.0, use numpy.correlate instead cos(...) scipy.cos is deprecated and will be removed in SciPy 2.0.0, use numpy.cos instead cosh(...) scipy.cosh is deprecated and will be removed in SciPy 2.0.0, use numpy.cosh instead count_nonzero(a, axis=None, *, keepdims=False) scipy.count_nonzero is deprecated and will be removed in SciPy 2.0.0, use numpy.count_nonzero instead cov(m, y=None, rowvar=True, bias=False, ddof=None, fweights=None, aweights=None) scipy.cov is deprecated and will be removed in SciPy 2.0.0, use numpy.cov instead cross(a, b, axisa=-1, axisb=-1, axisc=-1, axis=None) scipy.cross is deprecated and will be removed in SciPy 2.0.0, use numpy.cross instead cumprod(a, axis=None, dtype=None, out=None) scipy.cumprod is deprecated and will be removed in SciPy 2.0.0, use numpy.cumprod instead cumproduct(*args, **kwargs) scipy.cumproduct is deprecated and will be removed in SciPy 2.0.0, use numpy.cumproduct instead cumsum(a, axis=None, dtype=None, out=None) scipy.cumsum is deprecated and will be removed in SciPy 2.0.0, use numpy.cumsum instead datetime_as_string(...) scipy.datetime_as_string is deprecated and will be removed in SciPy 2.0.0, use numpy.datetime_as_string instead datetime_data(...) scipy.datetime_data is deprecated and will be removed in SciPy 2.0.0, use numpy.datetime_data instead deg2rad(...) scipy.deg2rad is deprecated and will be removed in SciPy 2.0.0, use numpy.deg2rad instead degrees(...) scipy.degrees is deprecated and will be removed in SciPy 2.0.0, use numpy.degrees instead delete(arr, obj, axis=None) scipy.delete is deprecated and will be removed in SciPy 2.0.0, use numpy.delete instead deprecate(*args, **kwargs) scipy.deprecate is deprecated and will be removed in SciPy 2.0.0, use numpy.deprecate instead deprecate_with_doc lambda msg scipy.deprecate_with_doc is deprecated and will be removed in SciPy 2.0.0, use numpy.deprecate_with_doc instead diag(v, k=0) scipy.diag is deprecated and will be removed in SciPy 2.0.0, use numpy.diag instead diag_indices(n, ndim=2) scipy.diag_indices is deprecated and will be removed in SciPy 2.0.0, use numpy.diag_indices instead diag_indices_from(arr) scipy.diag_indices_from is deprecated and will be removed in SciPy 2.0.0, use numpy.diag_indices_from instead diagflat(v, k=0) scipy.diagflat is deprecated and will be removed in SciPy 2.0.0, use numpy.diagflat instead diagonal(a, offset=0, axis1=0, axis2=1) scipy.diagonal is deprecated and will be removed in SciPy 2.0.0, use numpy.diagonal instead diff(a, n=1, axis=-1, prepend=<no value>, append=<no value>) scipy.diff is deprecated and will be removed in SciPy 2.0.0, use numpy.diff instead digitize(x, bins, right=False) scipy.digitize is deprecated and will be removed in SciPy 2.0.0, use numpy.digitize instead disp(mesg, device=None, linefeed=True) scipy.disp is deprecated and will be removed in SciPy 2.0.0, use numpy.disp instead divide = true_divide(...) scipy.divide is deprecated and will be removed in SciPy 2.0.0, use numpy.divide instead divmod(...) scipy.divmod is deprecated and will be removed in SciPy 2.0.0, use numpy.divmod instead dot(...) scipy.dot is deprecated and will be removed in SciPy 2.0.0, use numpy.dot instead dsplit(ary, indices_or_sections) scipy.dsplit is deprecated and will be removed in SciPy 2.0.0, use numpy.dsplit instead dstack(tup) scipy.dstack is deprecated and will be removed in SciPy 2.0.0, use numpy.dstack instead ediff1d(ary, to_end=None, to_begin=None) scipy.ediff1d is deprecated and will be removed in SciPy 2.0.0, use numpy.ediff1d instead einsum(*operands, out=None, optimize=False, **kwargs) scipy.einsum is deprecated and will be removed in SciPy 2.0.0, use numpy.einsum instead einsum_path(*operands, optimize='greedy', einsum_call=False) scipy.einsum_path is deprecated and will be removed in SciPy 2.0.0, use numpy.einsum_path instead empty(...) scipy.empty is deprecated and will be removed in SciPy 2.0.0, use numpy.empty instead empty_like(...) scipy.empty_like is deprecated and will be removed in SciPy 2.0.0, use numpy.empty_like instead equal(...) scipy.equal is deprecated and will be removed in SciPy 2.0.0, use numpy.equal instead exp(...) scipy.exp is deprecated and will be removed in SciPy 2.0.0, use numpy.exp instead exp2(...) scipy.exp2 is deprecated and will be removed in SciPy 2.0.0, use numpy.exp2 instead expand_dims(a, axis) scipy.expand_dims is deprecated and will be removed in SciPy 2.0.0, use numpy.expand_dims instead expm1(...) scipy.expm1 is deprecated and will be removed in SciPy 2.0.0, use numpy.expm1 instead extract(condition, arr) scipy.extract is deprecated and will be removed in SciPy 2.0.0, use numpy.extract instead eye(N, M=None, k=0, dtype=<class 'float'>, order='C') scipy.eye is deprecated and will be removed in SciPy 2.0.0, use numpy.eye instead fabs(...) scipy.fabs is deprecated and will be removed in SciPy 2.0.0, use numpy.fabs instead fastCopyAndTranspose = _fastCopyAndTranspose(...) scipy.fastCopyAndTranspose is deprecated and will be removed in SciPy 2.0.0, use numpy.fastCopyAndTranspose instead fill_diagonal(a, val, wrap=False) scipy.fill_diagonal is deprecated and will be removed in SciPy 2.0.0, use numpy.fill_diagonal instead find_common_type(array_types, scalar_types) scipy.find_common_type is deprecated and will be removed in SciPy 2.0.0, use numpy.find_common_type instead fix(x, out=None) scipy.fix is deprecated and will be removed in SciPy 2.0.0, use numpy.fix instead flatnonzero(a) scipy.flatnonzero is deprecated and will be removed in SciPy 2.0.0, use numpy.flatnonzero instead flip(m, axis=None) scipy.flip is deprecated and will be removed in SciPy 2.0.0, use numpy.flip instead fliplr(m) scipy.fliplr is deprecated and will be removed in SciPy 2.0.0, use numpy.fliplr instead flipud(m) scipy.flipud is deprecated and will be removed in SciPy 2.0.0, use numpy.flipud instead float_power(...) scipy.float_power is deprecated and will be removed in SciPy 2.0.0, use numpy.float_power instead floor(...) scipy.floor is deprecated and will be removed in SciPy 2.0.0, use numpy.floor instead floor_divide(...) scipy.floor_divide is deprecated and will be removed in SciPy 2.0.0, use numpy.floor_divide instead fmax(...) scipy.fmax is deprecated and will be removed in SciPy 2.0.0, use numpy.fmax instead fmin(...) scipy.fmin is deprecated and will be removed in SciPy 2.0.0, use numpy.fmin instead fmod(...) scipy.fmod is deprecated and will be removed in SciPy 2.0.0, use numpy.fmod instead format_float_positional(x, precision=None, unique=True, fractional=True, trim='k', sign=False, pad_left=None, pad_right=None) scipy.format_float_positional is deprecated and will be removed in SciPy 2.0.0, use numpy.format_float_positional instead format_float_scientific(x, precision=None, unique=True, trim='k', sign=False, pad_left=None, exp_digits=None) scipy.format_float_scientific is deprecated and will be removed in SciPy 2.0.0, use numpy.format_float_scientific instead frexp(...) scipy.frexp is deprecated and will be removed in SciPy 2.0.0, use numpy.frexp instead frombuffer(...) scipy.frombuffer is deprecated and will be removed in SciPy 2.0.0, use numpy.frombuffer instead fromfile(...) scipy.fromfile is deprecated and will be removed in SciPy 2.0.0, use numpy.fromfile instead fromfunction(function, shape, *, dtype=<class 'float'>, **kwargs) scipy.fromfunction is deprecated and will be removed in SciPy 2.0.0, use numpy.fromfunction instead fromiter(...) scipy.fromiter is deprecated and will be removed in SciPy 2.0.0, use numpy.fromiter instead frompyfunc(...) scipy.frompyfunc is deprecated and will be removed in SciPy 2.0.0, use numpy.frompyfunc instead fromregex(file, regexp, dtype, encoding=None) scipy.fromregex is deprecated and will be removed in SciPy 2.0.0, use numpy.fromregex instead fromstring(...) scipy.fromstring is deprecated and will be removed in SciPy 2.0.0, use numpy.fromstring instead full(shape, fill_value, dtype=None, order='C') scipy.full is deprecated and will be removed in SciPy 2.0.0, use numpy.full instead full_like(a, fill_value, dtype=None, order='K', subok=True, shape=None) scipy.full_like is deprecated and will be removed in SciPy 2.0.0, use numpy.full_like instead fv(rate, nper, pmt, pv, when='end') scipy.fv is deprecated and will be removed in SciPy 2.0.0, use numpy.fv instead gcd(...) scipy.gcd is deprecated and will be removed in SciPy 2.0.0, use numpy.gcd instead genfromtxt(fname, dtype=<class 'float'>, comments='#', delimiter=None, skip_header=0, skip_footer=0, converters=None, missing_values=None, filling_values=None, usecols=None, names=None, excludelist=None, deletechars=" !#$%&'()*+,-./:;<=>?@[\\]^{|}~", replace_space='_', autostrip=False, case_sensitive=True, defaultfmt='f%i', unpack=None, usemask=False, loose=True, invalid_raise=True, max_rows=None, encoding='bytes') scipy.genfromtxt is deprecated and will be removed in SciPy 2.0.0, use numpy.genfromtxt instead geomspace(start, stop, num=50, endpoint=True, dtype=None, axis=0) scipy.geomspace is deprecated and will be removed in SciPy 2.0.0, use numpy.geomspace instead get_array_wrap(*args) scipy.get_array_wrap is deprecated and will be removed in SciPy 2.0.0, use numpy.get_array_wrap instead get_include() scipy.get_include is deprecated and will be removed in SciPy 2.0.0, use numpy.get_include instead get_printoptions() scipy.get_printoptions is deprecated and will be removed in SciPy 2.0.0, use numpy.get_printoptions instead getbufsize() scipy.getbufsize is deprecated and will be removed in SciPy 2.0.0, use numpy.getbufsize instead geterr() scipy.geterr is deprecated and will be removed in SciPy 2.0.0, use numpy.geterr instead geterrcall() scipy.geterrcall is deprecated and will be removed in SciPy 2.0.0, use numpy.geterrcall instead geterrobj(...) scipy.geterrobj is deprecated and will be removed in SciPy 2.0.0, use numpy.geterrobj instead gradient(f, *varargs, axis=None, edge_order=1) scipy.gradient is deprecated and will be removed in SciPy 2.0.0, use numpy.gradient instead greater(...) scipy.greater is deprecated and will be removed in SciPy 2.0.0, use numpy.greater instead greater_equal(...) scipy.greater_equal is deprecated and will be removed in SciPy 2.0.0, use numpy.greater_equal instead hamming(M) scipy.hamming is deprecated and will be removed in SciPy 2.0.0, use numpy.hamming instead hanning(M) scipy.hanning is deprecated and will be removed in SciPy 2.0.0, use numpy.hanning instead heaviside(...) scipy.heaviside is deprecated and will be removed in SciPy 2.0.0, use numpy.heaviside instead histogram(a, bins=10, range=None, normed=None, weights=None, density=None) scipy.histogram is deprecated and will be removed in SciPy 2.0.0, use numpy.histogram instead histogram2d(x, y, bins=10, range=None, normed=None, weights=None, density=None) scipy.histogram2d is deprecated and will be removed in SciPy 2.0.0, use numpy.histogram2d instead histogram_bin_edges(a, bins=10, range=None, weights=None) scipy.histogram_bin_edges is deprecated and will be removed in SciPy 2.0.0, use numpy.histogram_bin_edges instead histogramdd(sample, bins=10, range=None, normed=None, weights=None, density=None) scipy.histogramdd is deprecated and will be removed in SciPy 2.0.0, use numpy.histogramdd instead hsplit(ary, indices_or_sections) scipy.hsplit is deprecated and will be removed in SciPy 2.0.0, use numpy.hsplit instead hstack(tup) scipy.hstack is deprecated and will be removed in SciPy 2.0.0, use numpy.hstack instead hypot(...) scipy.hypot is deprecated and will be removed in SciPy 2.0.0, use numpy.hypot instead i0(x) scipy.i0 is deprecated and will be removed in SciPy 2.0.0, use numpy.i0 instead identity(n, dtype=None) scipy.identity is deprecated and will be removed in SciPy 2.0.0, use numpy.identity instead ifft(a, n=None, axis=-1, norm=None) scipy.ifft is deprecated and will be removed in SciPy 2.0.0, use scipy.fft.ifft instead imag(val) scipy.imag is deprecated and will be removed in SciPy 2.0.0, use numpy.imag instead in1d(ar1, ar2, assume_unique=False, invert=False) scipy.in1d is deprecated and will be removed in SciPy 2.0.0, use numpy.in1d instead indices(dimensions, dtype=<class 'int'>, sparse=False) scipy.indices is deprecated and will be removed in SciPy 2.0.0, use numpy.indices instead info(object=None, maxwidth=76, output=<ipykernel.iostream.OutStream object at 0x7f9926cbd490>, toplevel='numpy') scipy.info is deprecated and will be removed in SciPy 2.0.0, use numpy.info instead inner(...) scipy.inner is deprecated and will be removed in SciPy 2.0.0, use numpy.inner instead insert(arr, obj, values, axis=None) scipy.insert is deprecated and will be removed in SciPy 2.0.0, use numpy.insert instead interp(x, xp, fp, left=None, right=None, period=None) scipy.interp is deprecated and will be removed in SciPy 2.0.0, use numpy.interp instead intersect1d(ar1, ar2, assume_unique=False, return_indices=False) scipy.intersect1d is deprecated and will be removed in SciPy 2.0.0, use numpy.intersect1d instead invert(...) scipy.invert is deprecated and will be removed in SciPy 2.0.0, use numpy.invert instead ipmt(rate, per, nper, pv, fv=0, when='end') scipy.ipmt is deprecated and will be removed in SciPy 2.0.0, use numpy.ipmt instead irr(values) scipy.irr is deprecated and will be removed in SciPy 2.0.0, use numpy.irr instead is_busday(...) scipy.is_busday is deprecated and will be removed in SciPy 2.0.0, use numpy.is_busday instead isclose(a, b, rtol=1e-05, atol=1e-08, equal_nan=False) scipy.isclose is deprecated and will be removed in SciPy 2.0.0, use numpy.isclose instead iscomplex(x) scipy.iscomplex is deprecated and will be removed in SciPy 2.0.0, use numpy.iscomplex instead iscomplexobj(x) scipy.iscomplexobj is deprecated and will be removed in SciPy 2.0.0, use numpy.iscomplexobj instead isfinite(...) scipy.isfinite is deprecated and will be removed in SciPy 2.0.0, use numpy.isfinite instead isfortran(a) scipy.isfortran is deprecated and will be removed in SciPy 2.0.0, use numpy.isfortran instead isin(element, test_elements, assume_unique=False, invert=False) scipy.isin is deprecated and will be removed in SciPy 2.0.0, use numpy.isin instead isinf(...) scipy.isinf is deprecated and will be removed in SciPy 2.0.0, use numpy.isinf instead isnan(...) scipy.isnan is deprecated and will be removed in SciPy 2.0.0, use numpy.isnan instead isnat(...) scipy.isnat is deprecated and will be removed in SciPy 2.0.0, use numpy.isnat instead isneginf(x, out=None) scipy.isneginf is deprecated and will be removed in SciPy 2.0.0, use numpy.isneginf instead isposinf(x, out=None) scipy.isposinf is deprecated and will be removed in SciPy 2.0.0, use numpy.isposinf instead isreal(x) scipy.isreal is deprecated and will be removed in SciPy 2.0.0, use numpy.isreal instead isrealobj(x) scipy.isrealobj is deprecated and will be removed in SciPy 2.0.0, use numpy.isrealobj instead isscalar(element) scipy.isscalar is deprecated and will be removed in SciPy 2.0.0, use numpy.isscalar instead issctype(rep) scipy.issctype is deprecated and will be removed in SciPy 2.0.0, use numpy.issctype instead issubclass_(arg1, arg2) scipy.issubclass_ is deprecated and will be removed in SciPy 2.0.0, use numpy.issubclass_ instead issubdtype(arg1, arg2) scipy.issubdtype is deprecated and will be removed in SciPy 2.0.0, use numpy.issubdtype instead issubsctype(arg1, arg2) scipy.issubsctype is deprecated and will be removed in SciPy 2.0.0, use numpy.issubsctype instead iterable(y) scipy.iterable is deprecated and will be removed in SciPy 2.0.0, use numpy.iterable instead ix_(*args) scipy.ix_ is deprecated and will be removed in SciPy 2.0.0, use numpy.ix_ instead kaiser(M, beta) scipy.kaiser is deprecated and will be removed in SciPy 2.0.0, use numpy.kaiser instead kron(a, b) scipy.kron is deprecated and will be removed in SciPy 2.0.0, use numpy.kron instead lcm(...) scipy.lcm is deprecated and will be removed in SciPy 2.0.0, use numpy.lcm instead ldexp(...) scipy.ldexp is deprecated and will be removed in SciPy 2.0.0, use numpy.ldexp instead left_shift(...) scipy.left_shift is deprecated and will be removed in SciPy 2.0.0, use numpy.left_shift instead less(...) scipy.less is deprecated and will be removed in SciPy 2.0.0, use numpy.less instead less_equal(...) scipy.less_equal is deprecated and will be removed in SciPy 2.0.0, use numpy.less_equal instead lexsort(...) scipy.lexsort is deprecated and will be removed in SciPy 2.0.0, use numpy.lexsort instead linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None, axis=0) scipy.linspace is deprecated and will be removed in SciPy 2.0.0, use numpy.linspace instead load(file, mmap_mode=None, allow_pickle=False, fix_imports=True, encoding='ASCII') scipy.load is deprecated and will be removed in SciPy 2.0.0, use numpy.load instead loads(*args, **kwargs) scipy.loads is deprecated and will be removed in SciPy 2.0.0, use numpy.loads instead loadtxt(fname, dtype=<class 'float'>, comments='#', delimiter=None, converters=None, skiprows=0, usecols=None, unpack=False, ndmin=0, encoding='bytes', max_rows=None) scipy.loadtxt is deprecated and will be removed in SciPy 2.0.0, use numpy.loadtxt instead log(x) scipy.log is deprecated and will be removed in SciPy 2.0.0, use numpy.lib.scimath.log instead log10(x) scipy.log10 is deprecated and will be removed in SciPy 2.0.0, use numpy.lib.scimath.log10 instead log1p(...) scipy.log1p is deprecated and will be removed in SciPy 2.0.0, use numpy.log1p instead log2(x) scipy.log2 is deprecated and will be removed in SciPy 2.0.0, use numpy.lib.scimath.log2 instead logaddexp(...) scipy.logaddexp is deprecated and will be removed in SciPy 2.0.0, use numpy.logaddexp instead logaddexp2(...) scipy.logaddexp2 is deprecated and will be removed in SciPy 2.0.0, use numpy.logaddexp2 instead logical_and(...) scipy.logical_and is deprecated and will be removed in SciPy 2.0.0, use numpy.logical_and instead logical_not(...) scipy.logical_not is deprecated and will be removed in SciPy 2.0.0, use numpy.logical_not instead logical_or(...) scipy.logical_or is deprecated and will be removed in SciPy 2.0.0, use numpy.logical_or instead logical_xor(...) scipy.logical_xor is deprecated and will be removed in SciPy 2.0.0, use numpy.logical_xor instead logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None, axis=0) scipy.logspace is deprecated and will be removed in SciPy 2.0.0, use numpy.logspace instead lookfor(what, module=None, import_modules=True, regenerate=False, output=None) scipy.lookfor is deprecated and will be removed in SciPy 2.0.0, use numpy.lookfor instead mafromtxt(fname, **kwargs) scipy.mafromtxt is deprecated and will be removed in SciPy 2.0.0, use numpy.mafromtxt instead mask_indices(n, mask_func, k=0) scipy.mask_indices is deprecated and will be removed in SciPy 2.0.0, use numpy.mask_indices instead mat = asmatrix(data, dtype=None) scipy.mat is deprecated and will be removed in SciPy 2.0.0, use numpy.mat instead matmul(...) scipy.matmul is deprecated and will be removed in SciPy 2.0.0, use numpy.matmul instead maximum(...) scipy.maximum is deprecated and will be removed in SciPy 2.0.0, use numpy.maximum instead maximum_sctype(t) scipy.maximum_sctype is deprecated and will be removed in SciPy 2.0.0, use numpy.maximum_sctype instead may_share_memory(...) scipy.may_share_memory is deprecated and will be removed in SciPy 2.0.0, use numpy.may_share_memory instead mean(a, axis=None, dtype=None, out=None, keepdims=<no value>) scipy.mean is deprecated and will be removed in SciPy 2.0.0, use numpy.mean instead median(a, axis=None, out=None, overwrite_input=False, keepdims=False) scipy.median is deprecated and will be removed in SciPy 2.0.0, use numpy.median instead meshgrid(*xi, copy=True, sparse=False, indexing='xy') scipy.meshgrid is deprecated and will be removed in SciPy 2.0.0, use numpy.meshgrid instead min_scalar_type(...) scipy.min_scalar_type is deprecated and will be removed in SciPy 2.0.0, use numpy.min_scalar_type instead minimum(...) scipy.minimum is deprecated and will be removed in SciPy 2.0.0, use numpy.minimum instead mintypecode(typechars, typeset='GDFgdf', default='d') scipy.mintypecode is deprecated and will be removed in SciPy 2.0.0, use numpy.mintypecode instead mirr(values, finance_rate, reinvest_rate) scipy.mirr is deprecated and will be removed in SciPy 2.0.0, use numpy.mirr instead mod = remainder(...) scipy.mod is deprecated and will be removed in SciPy 2.0.0, use numpy.mod instead modf(...) scipy.modf is deprecated and will be removed in SciPy 2.0.0, use numpy.modf instead moveaxis(a, source, destination) scipy.moveaxis is deprecated and will be removed in SciPy 2.0.0, use numpy.moveaxis instead msort(a) scipy.msort is deprecated and will be removed in SciPy 2.0.0, use numpy.msort instead multiply(...) scipy.multiply is deprecated and will be removed in SciPy 2.0.0, use numpy.multiply instead nan_to_num(x, copy=True, nan=0.0, posinf=None, neginf=None) scipy.nan_to_num is deprecated and will be removed in SciPy 2.0.0, use numpy.nan_to_num instead nanargmax(a, axis=None) scipy.nanargmax is deprecated and will be removed in SciPy 2.0.0, use numpy.nanargmax instead nanargmin(a, axis=None) scipy.nanargmin is deprecated and will be removed in SciPy 2.0.0, use numpy.nanargmin instead nancumprod(a, axis=None, dtype=None, out=None) scipy.nancumprod is deprecated and will be removed in SciPy 2.0.0, use numpy.nancumprod instead nancumsum(a, axis=None, dtype=None, out=None) scipy.nancumsum is deprecated and will be removed in SciPy 2.0.0, use numpy.nancumsum instead nanmax(a, axis=None, out=None, keepdims=<no value>) scipy.nanmax is deprecated and will be removed in SciPy 2.0.0, use numpy.nanmax instead nanmean(a, axis=None, dtype=None, out=None, keepdims=<no value>) scipy.nanmean is deprecated and will be removed in SciPy 2.0.0, use numpy.nanmean instead nanmedian(a, axis=None, out=None, overwrite_input=False, keepdims=<no value>) scipy.nanmedian is deprecated and will be removed in SciPy 2.0.0, use numpy.nanmedian instead nanmin(a, axis=None, out=None, keepdims=<no value>) scipy.nanmin is deprecated and will be removed in SciPy 2.0.0, use numpy.nanmin instead nanpercentile(a, q, axis=None, out=None, overwrite_input=False, interpolation='linear', keepdims=<no value>) scipy.nanpercentile is deprecated and will be removed in SciPy 2.0.0, use numpy.nanpercentile instead nanprod(a, axis=None, dtype=None, out=None, keepdims=<no value>) scipy.nanprod is deprecated and will be removed in SciPy 2.0.0, use numpy.nanprod instead nanquantile(a, q, axis=None, out=None, overwrite_input=False, interpolation='linear', keepdims=<no value>) scipy.nanquantile is deprecated and will be removed in SciPy 2.0.0, use numpy.nanquantile instead nanstd(a, axis=None, dtype=None, out=None, ddof=0, keepdims=<no value>) scipy.nanstd is deprecated and will be removed in SciPy 2.0.0, use numpy.nanstd instead nansum(a, axis=None, dtype=None, out=None, keepdims=<no value>) scipy.nansum is deprecated and will be removed in SciPy 2.0.0, use numpy.nansum instead nanvar(a, axis=None, dtype=None, out=None, ddof=0, keepdims=<no value>) scipy.nanvar is deprecated and will be removed in SciPy 2.0.0, use numpy.nanvar instead ndfromtxt(fname, **kwargs) scipy.ndfromtxt is deprecated and will be removed in SciPy 2.0.0, use numpy.ndfromtxt instead ndim(a) scipy.ndim is deprecated and will be removed in SciPy 2.0.0, use numpy.ndim instead negative(...) scipy.negative is deprecated and will be removed in SciPy 2.0.0, use numpy.negative instead nested_iters(...) scipy.nested_iters is deprecated and will be removed in SciPy 2.0.0, use numpy.nested_iters instead nextafter(...) scipy.nextafter is deprecated and will be removed in SciPy 2.0.0, use numpy.nextafter instead nonzero(a) scipy.nonzero is deprecated and will be removed in SciPy 2.0.0, use numpy.nonzero instead not_equal(...) scipy.not_equal is deprecated and will be removed in SciPy 2.0.0, use numpy.not_equal instead nper(rate, pmt, pv, fv=0, when='end') scipy.nper is deprecated and will be removed in SciPy 2.0.0, use numpy.nper instead npv(rate, values) scipy.npv is deprecated and will be removed in SciPy 2.0.0, use numpy.npv instead obj2sctype(rep, default=None) scipy.obj2sctype is deprecated and will be removed in SciPy 2.0.0, use numpy.obj2sctype instead ones(shape, dtype=None, order='C') scipy.ones is deprecated and will be removed in SciPy 2.0.0, use numpy.ones instead ones_like(a, dtype=None, order='K', subok=True, shape=None) scipy.ones_like is deprecated and will be removed in SciPy 2.0.0, use numpy.ones_like instead outer(a, b, out=None) scipy.outer is deprecated and will be removed in SciPy 2.0.0, use numpy.outer instead packbits(...) scipy.packbits is deprecated and will be removed in SciPy 2.0.0, use numpy.packbits instead pad(array, pad_width, mode='constant', **kwargs) scipy.pad is deprecated and will be removed in SciPy 2.0.0, use numpy.pad instead partition(a, kth, axis=-1, kind='introselect', order=None) scipy.partition is deprecated and will be removed in SciPy 2.0.0, use numpy.partition instead percentile(a, q, axis=None, out=None, overwrite_input=False, interpolation='linear', keepdims=False) scipy.percentile is deprecated and will be removed in SciPy 2.0.0, use numpy.percentile instead piecewise(x, condlist, funclist, *args, **kw) scipy.piecewise is deprecated and will be removed in SciPy 2.0.0, use numpy.piecewise instead place(arr, mask, vals) scipy.place is deprecated and will be removed in SciPy 2.0.0, use numpy.place instead pmt(rate, nper, pv, fv=0, when='end') scipy.pmt is deprecated and will be removed in SciPy 2.0.0, use numpy.pmt instead poly(seq_of_zeros) scipy.poly is deprecated and will be removed in SciPy 2.0.0, use numpy.poly instead polyadd(a1, a2) scipy.polyadd is deprecated and will be removed in SciPy 2.0.0, use numpy.polyadd instead polyder(p, m=1) scipy.polyder is deprecated and will be removed in SciPy 2.0.0, use numpy.polyder instead polydiv(u, v) scipy.polydiv is deprecated and will be removed in SciPy 2.0.0, use numpy.polydiv instead polyfit(x, y, deg, rcond=None, full=False, w=None, cov=False) scipy.polyfit is deprecated and will be removed in SciPy 2.0.0, use numpy.polyfit instead polyint(p, m=1, k=None) scipy.polyint is deprecated and will be removed in SciPy 2.0.0, use numpy.polyint instead polymul(a1, a2) scipy.polymul is deprecated and will be removed in SciPy 2.0.0, use numpy.polymul instead polysub(a1, a2) scipy.polysub is deprecated and will be removed in SciPy 2.0.0, use numpy.polysub instead polyval(p, x) scipy.polyval is deprecated and will be removed in SciPy 2.0.0, use numpy.polyval instead positive(...) scipy.positive is deprecated and will be removed in SciPy 2.0.0, use numpy.positive instead power(x, p) scipy.power is deprecated and will be removed in SciPy 2.0.0, use numpy.lib.scimath.power instead ppmt(rate, per, nper, pv, fv=0, when='end') scipy.ppmt is deprecated and will be removed in SciPy 2.0.0, use numpy.ppmt instead printoptions(*args, **kwargs) scipy.printoptions is deprecated and will be removed in SciPy 2.0.0, use numpy.printoptions instead prod(a, axis=None, dtype=None, out=None, keepdims=<no value>, initial=<no value>, where=<no value>) scipy.prod is deprecated and will be removed in SciPy 2.0.0, use numpy.prod instead product(*args, **kwargs) scipy.product is deprecated and will be removed in SciPy 2.0.0, use numpy.product instead promote_types(...) scipy.promote_types is deprecated and will be removed in SciPy 2.0.0, use numpy.promote_types instead ptp(a, axis=None, out=None, keepdims=<no value>) scipy.ptp is deprecated and will be removed in SciPy 2.0.0, use numpy.ptp instead put(a, ind, v, mode='raise') scipy.put is deprecated and will be removed in SciPy 2.0.0, use numpy.put instead put_along_axis(arr, indices, values, axis) scipy.put_along_axis is deprecated and will be removed in SciPy 2.0.0, use numpy.put_along_axis instead putmask(...) scipy.putmask is deprecated and will be removed in SciPy 2.0.0, use numpy.putmask instead pv(rate, nper, pmt, fv=0, when='end') scipy.pv is deprecated and will be removed in SciPy 2.0.0, use numpy.pv instead quantile(a, q, axis=None, out=None, overwrite_input=False, interpolation='linear', keepdims=False) scipy.quantile is deprecated and will be removed in SciPy 2.0.0, use numpy.quantile instead rad2deg(...) scipy.rad2deg is deprecated and will be removed in SciPy 2.0.0, use numpy.rad2deg instead radians(...) scipy.radians is deprecated and will be removed in SciPy 2.0.0, use numpy.radians instead rand(...) scipy.rand is deprecated and will be removed in SciPy 2.0.0, use numpy.random.rand instead randn(...) scipy.randn is deprecated and will be removed in SciPy 2.0.0, use numpy.random.randn instead rate(nper, pmt, pv, fv, when='end', guess=None, tol=None, maxiter=100) scipy.rate is deprecated and will be removed in SciPy 2.0.0, use numpy.rate instead ravel(a, order='C') scipy.ravel is deprecated and will be removed in SciPy 2.0.0, use numpy.ravel instead ravel_multi_index(...) scipy.ravel_multi_index is deprecated and will be removed in SciPy 2.0.0, use numpy.ravel_multi_index instead real(val) scipy.real is deprecated and will be removed in SciPy 2.0.0, use numpy.real instead real_if_close(a, tol=100) scipy.real_if_close is deprecated and will be removed in SciPy 2.0.0, use numpy.real_if_close instead recfromcsv(fname, **kwargs) scipy.recfromcsv is deprecated and will be removed in SciPy 2.0.0, use numpy.recfromcsv instead recfromtxt(fname, **kwargs) scipy.recfromtxt is deprecated and will be removed in SciPy 2.0.0, use numpy.recfromtxt instead reciprocal(...) scipy.reciprocal is deprecated and will be removed in SciPy 2.0.0, use numpy.reciprocal instead remainder(...) scipy.remainder is deprecated and will be removed in SciPy 2.0.0, use numpy.remainder instead repeat(a, repeats, axis=None) scipy.repeat is deprecated and will be removed in SciPy 2.0.0, use numpy.repeat instead require(a, dtype=None, requirements=None) scipy.require is deprecated and will be removed in SciPy 2.0.0, use numpy.require instead reshape(a, newshape, order='C') scipy.reshape is deprecated and will be removed in SciPy 2.0.0, use numpy.reshape instead resize(a, new_shape) scipy.resize is deprecated and will be removed in SciPy 2.0.0, use numpy.resize instead result_type(...) scipy.result_type is deprecated and will be removed in SciPy 2.0.0, use numpy.result_type instead right_shift(...) scipy.right_shift is deprecated and will be removed in SciPy 2.0.0, use numpy.right_shift instead rint(...) scipy.rint is deprecated and will be removed in SciPy 2.0.0, use numpy.rint instead roll(a, shift, axis=None) scipy.roll is deprecated and will be removed in SciPy 2.0.0, use numpy.roll instead rollaxis(a, axis, start=0) scipy.rollaxis is deprecated and will be removed in SciPy 2.0.0, use numpy.rollaxis instead roots(p) scipy.roots is deprecated and will be removed in SciPy 2.0.0, use numpy.roots instead rot90(m, k=1, axes=(0, 1)) scipy.rot90 is deprecated and will be removed in SciPy 2.0.0, use numpy.rot90 instead round_(a, decimals=0, out=None) scipy.round_ is deprecated and will be removed in SciPy 2.0.0, use numpy.round_ instead row_stack = vstack(tup) scipy.row_stack is deprecated and will be removed in SciPy 2.0.0, use numpy.row_stack instead safe_eval(source) scipy.safe_eval is deprecated and will be removed in SciPy 2.0.0, use numpy.safe_eval instead save(file, arr, allow_pickle=True, fix_imports=True) scipy.save is deprecated and will be removed in SciPy 2.0.0, use numpy.save instead savetxt(fname, X, fmt='%.18e', delimiter=' ', newline='\n', header='', footer='', comments='# ', encoding=None) scipy.savetxt is deprecated and will be removed in SciPy 2.0.0, use numpy.savetxt instead savez(file, *args, **kwds) scipy.savez is deprecated and will be removed in SciPy 2.0.0, use numpy.savez instead savez_compressed(file, *args, **kwds) scipy.savez_compressed is deprecated and will be removed in SciPy 2.0.0, use numpy.savez_compressed instead sctype2char(sctype) scipy.sctype2char is deprecated and will be removed in SciPy 2.0.0, use numpy.sctype2char instead searchsorted(a, v, side='left', sorter=None) scipy.searchsorted is deprecated and will be removed in SciPy 2.0.0, use numpy.searchsorted instead select(condlist, choicelist, default=0) scipy.select is deprecated and will be removed in SciPy 2.0.0, use numpy.select instead set_numeric_ops(...) scipy.set_numeric_ops is deprecated and will be removed in SciPy 2.0.0, use numpy.set_numeric_ops instead set_printoptions(precision=None, threshold=None, edgeitems=None, linewidth=None, suppress=None, nanstr=None, infstr=None, formatter=None, sign=None, floatmode=None, *, legacy=None) scipy.set_printoptions is deprecated and will be removed in SciPy 2.0.0, use numpy.set_printoptions instead set_string_function(f, repr=True) scipy.set_string_function is deprecated and will be removed in SciPy 2.0.0, use numpy.set_string_function instead setbufsize(size) scipy.setbufsize is deprecated and will be removed in SciPy 2.0.0, use numpy.setbufsize instead setdiff1d(ar1, ar2, assume_unique=False) scipy.setdiff1d is deprecated and will be removed in SciPy 2.0.0, use numpy.setdiff1d instead seterr(all=None, divide=None, over=None, under=None, invalid=None) scipy.seterr is deprecated and will be removed in SciPy 2.0.0, use numpy.seterr instead seterrcall(func) scipy.seterrcall is deprecated and will be removed in SciPy 2.0.0, use numpy.seterrcall instead seterrobj(...) scipy.seterrobj is deprecated and will be removed in SciPy 2.0.0, use numpy.seterrobj instead setxor1d(ar1, ar2, assume_unique=False) scipy.setxor1d is deprecated and will be removed in SciPy 2.0.0, use numpy.setxor1d instead shape(a) scipy.shape is deprecated and will be removed in SciPy 2.0.0, use numpy.shape instead shares_memory(...) scipy.shares_memory is deprecated and will be removed in SciPy 2.0.0, use numpy.shares_memory instead show_config = show() sign(...) scipy.sign is deprecated and will be removed in SciPy 2.0.0, use numpy.sign instead signbit(...) scipy.signbit is deprecated and will be removed in SciPy 2.0.0, use numpy.signbit instead sin(...) scipy.sin is deprecated and will be removed in SciPy 2.0.0, use numpy.sin instead sinc(x) scipy.sinc is deprecated and will be removed in SciPy 2.0.0, use numpy.sinc instead sinh(...) scipy.sinh is deprecated and will be removed in SciPy 2.0.0, use numpy.sinh instead size(a, axis=None) scipy.size is deprecated and will be removed in SciPy 2.0.0, use numpy.size instead sometrue(*args, **kwargs) scipy.sometrue is deprecated and will be removed in SciPy 2.0.0, use numpy.sometrue instead sort(a, axis=-1, kind=None, order=None) scipy.sort is deprecated and will be removed in SciPy 2.0.0, use numpy.sort instead sort_complex(a) scipy.sort_complex is deprecated and will be removed in SciPy 2.0.0, use numpy.sort_complex instead source(object, output=<ipykernel.iostream.OutStream object at 0x7f9926cbd490>) scipy.source is deprecated and will be removed in SciPy 2.0.0, use numpy.source instead spacing(...) scipy.spacing is deprecated and will be removed in SciPy 2.0.0, use numpy.spacing instead split(ary, indices_or_sections, axis=0) scipy.split is deprecated and will be removed in SciPy 2.0.0, use numpy.split instead sqrt(x) scipy.sqrt is deprecated and will be removed in SciPy 2.0.0, use numpy.lib.scimath.sqrt instead square(...) scipy.square is deprecated and will be removed in SciPy 2.0.0, use numpy.square instead squeeze(a, axis=None) scipy.squeeze is deprecated and will be removed in SciPy 2.0.0, use numpy.squeeze instead stack(arrays, axis=0, out=None) scipy.stack is deprecated and will be removed in SciPy 2.0.0, use numpy.stack instead std(a, axis=None, dtype=None, out=None, ddof=0, keepdims=<no value>) scipy.std is deprecated and will be removed in SciPy 2.0.0, use numpy.std instead subtract(...) scipy.subtract is deprecated and will be removed in SciPy 2.0.0, use numpy.subtract instead sum(a, axis=None, dtype=None, out=None, keepdims=<no value>, initial=<no value>, where=<no value>) scipy.sum is deprecated and will be removed in SciPy 2.0.0, use numpy.sum instead swapaxes(a, axis1, axis2) scipy.swapaxes is deprecated and will be removed in SciPy 2.0.0, use numpy.swapaxes instead take(a, indices, axis=None, out=None, mode='raise') scipy.take is deprecated and will be removed in SciPy 2.0.0, use numpy.take instead take_along_axis(arr, indices, axis) scipy.take_along_axis is deprecated and will be removed in SciPy 2.0.0, use numpy.take_along_axis instead tan(...) scipy.tan is deprecated and will be removed in SciPy 2.0.0, use numpy.tan instead tanh(...) scipy.tanh is deprecated and will be removed in SciPy 2.0.0, use numpy.tanh instead tensordot(a, b, axes=2) scipy.tensordot is deprecated and will be removed in SciPy 2.0.0, use numpy.tensordot instead tile(A, reps) scipy.tile is deprecated and will be removed in SciPy 2.0.0, use numpy.tile instead trace(a, offset=0, axis1=0, axis2=1, dtype=None, out=None) scipy.trace is deprecated and will be removed in SciPy 2.0.0, use numpy.trace instead transpose(a, axes=None) scipy.transpose is deprecated and will be removed in SciPy 2.0.0, use numpy.transpose instead trapz(y, x=None, dx=1.0, axis=-1) scipy.trapz is deprecated and will be removed in SciPy 2.0.0, use numpy.trapz instead tri(N, M=None, k=0, dtype=<class 'float'>) scipy.tri is deprecated and will be removed in SciPy 2.0.0, use numpy.tri instead tril(m, k=0) scipy.tril is deprecated and will be removed in SciPy 2.0.0, use numpy.tril instead tril_indices(n, k=0, m=None) scipy.tril_indices is deprecated and will be removed in SciPy 2.0.0, use numpy.tril_indices instead tril_indices_from(arr, k=0) scipy.tril_indices_from is deprecated and will be removed in SciPy 2.0.0, use numpy.tril_indices_from instead trim_zeros(filt, trim='fb') scipy.trim_zeros is deprecated and will be removed in SciPy 2.0.0, use numpy.trim_zeros instead triu(m, k=0) scipy.triu is deprecated and will be removed in SciPy 2.0.0, use numpy.triu instead triu_indices(n, k=0, m=None) scipy.triu_indices is deprecated and will be removed in SciPy 2.0.0, use numpy.triu_indices instead triu_indices_from(arr, k=0) scipy.triu_indices_from is deprecated and will be removed in SciPy 2.0.0, use numpy.triu_indices_from instead true_divide(...) scipy.true_divide is deprecated and will be removed in SciPy 2.0.0, use numpy.true_divide instead trunc(...) scipy.trunc is deprecated and will be removed in SciPy 2.0.0, use numpy.trunc instead typename(char) scipy.typename is deprecated and will be removed in SciPy 2.0.0, use numpy.typename instead union1d(ar1, ar2) scipy.union1d is deprecated and will be removed in SciPy 2.0.0, use numpy.union1d instead unique(ar, return_index=False, return_inverse=False, return_counts=False, axis=None) scipy.unique is deprecated and will be removed in SciPy 2.0.0, use numpy.unique instead unpackbits(...) scipy.unpackbits is deprecated and will be removed in SciPy 2.0.0, use numpy.unpackbits instead unravel_index(...) scipy.unravel_index is deprecated and will be removed in SciPy 2.0.0, use numpy.unravel_index instead unwrap(p, discont=3.141592653589793, axis=-1) scipy.unwrap is deprecated and will be removed in SciPy 2.0.0, use numpy.unwrap instead vander(x, N=None, increasing=False) scipy.vander is deprecated and will be removed in SciPy 2.0.0, use numpy.vander instead var(a, axis=None, dtype=None, out=None, ddof=0, keepdims=<no value>) scipy.var is deprecated and will be removed in SciPy 2.0.0, use numpy.var instead vdot(...) scipy.vdot is deprecated and will be removed in SciPy 2.0.0, use numpy.vdot instead vsplit(ary, indices_or_sections) scipy.vsplit is deprecated and will be removed in SciPy 2.0.0, use numpy.vsplit instead vstack(tup) scipy.vstack is deprecated and will be removed in SciPy 2.0.0, use numpy.vstack instead where(...) scipy.where is deprecated and will be removed in SciPy 2.0.0, use numpy.where instead who(vardict=None) scipy.who is deprecated and will be removed in SciPy 2.0.0, use numpy.who instead zeros(...) scipy.zeros is deprecated and will be removed in SciPy 2.0.0, use numpy.zeros instead zeros_like(a, dtype=None, order='K', subok=True, shape=None) scipy.zeros_like is deprecated and will be removed in SciPy 2.0.0, use numpy.zeros_like instead DATA ALLOW_THREADS = 1 BUFSIZE = 8192 CLIP = 0 ERR_CALL = 3 ERR_DEFAULT = 521 ERR_IGNORE = 0 ERR_LOG = 5 ERR_PRINT = 4 ERR_RAISE = 2 ERR_WARN = 1 FLOATING_POINT_SUPPORT = 1 FPE_DIVIDEBYZERO = 1 FPE_INVALID = 8 FPE_OVERFLOW = 2 FPE_UNDERFLOW = 4 False_ = False Inf = inf Infinity = inf MAXDIMS = 32 MAY_SHARE_BOUNDS = 0 MAY_SHARE_EXACT = -1 NAN = nan NINF = -inf NZERO = -0.0 NaN = nan PINF = inf PZERO = 0.0 RAISE = 2 SHIFT_DIVIDEBYZERO = 0 SHIFT_INVALID = 9 SHIFT_OVERFLOW = 3 SHIFT_UNDERFLOW = 6 ScalarType = (<class 'int'>, <class 'float'>, <class 'complex'>, <clas... True_ = True UFUNC_BUFSIZE_DEFAULT = 8192 UFUNC_PYVALS_NAME = 'UFUNC_PYVALS' WRAP = 1 _UFUNC_API = <capsule object NULL> __SCIPY_SETUP__ = False __all__ = ['test', 'ModuleDeprecationWarning', 'VisibleDeprecationWarn... __numpy_version__ = '1.19.5' c_ = <numpy.lib.index_tricks.CClass object> cast = {<class 'numpy.object_'>: <function <lambda> at ...py.int8'>: <... e = 2.718281828459045 euler_gamma = 0.5772156649015329 index_exp = <numpy.lib.index_tricks.IndexExpression object> inf = inf infty = inf little_endian = True mgrid = <numpy.lib.index_tricks.MGridClass object> nan = nan nbytes = {<class 'numpy.bool_'>: 1, <class 'numpy.int8'>:....datetime6... newaxis = None ogrid = <numpy.lib.index_tricks.OGridClass object> pi = 3.141592653589793 r_ = <numpy.lib.index_tricks.RClass object> s_ = <numpy.lib.index_tricks.IndexExpression object> sctypeDict = {'?': <class 'numpy.bool_'>, 0: <class 'numpy.bool_'>, 'b... sctypeNA = {'Bool': <class 'numpy.bool_'>, <class 'numpy.bo...'>, <cla... sctypes = {'complex': [<class 'numpy.complex64'>, <class 'numpy.comple... test = <scipy._lib._testutils.PytestTester object> tracemalloc_domain = 389047 typeDict = {'?': <class 'numpy.bool_'>, 0: <class 'numpy.bool_'>, 'byt... typeNA = {'Bool': <class 'numpy.bool_'>, <class 'numpy.bo...'>, <class... typecodes = {'All': '?bhilqpBHILQPefdgFDGSUVOMm', 'AllFloat': 'efdgFDG... VERSION 1.5.2 FILE /home/franck/.local/lib/python3.8/site-packages/scipy/__init__.py
Since a package (like scipy
) is a collection of modules, you can import only a part of it. See https://docs.scipy.org/doc/scipy/reference/tutorial/index.html#user-guide for instance.
from scipy.stats import norm
norm.pdf(0.5)
0.3520653267642995
In order to reuse parts of your code, it is often efficient to write you own modules for often used functions. The importation of the module is the same as for other libraries to the difference that you have to give the (relative) path to the module.
In our example, the module file is pyds.py
in the ./lib/
folder (you may open it to see what it contains). Two solutions to give the (relative) path to the module:
./lib
to the folder list of pythonimport sys
sys.path.append( "./lib" )
import pyds as pyds1
help(pyds1)
Help on module pyds: NAME pyds DESCRIPTION ###################################### ### ### the CLASS module ### ###################################### FUNCTIONS printQuote() DATA teacherName = 'Franck Iutzeler' teacherWebsite = 'http://www.iutzeler.org' FILE /home/franck/Pro/Cours/2021-2022/M1SSD_Python/Introduction-to-Python-for-Data-Sciences/lib/pyds.py
lib
folder name as a package proxy (requires the presence of a - potentially void - file named __init__.py
in the folder)import lib.pyds as pyds2
pyds2.printQuote()
The joy of coding Python should be in seeing short, concise, readable classes that express a lot of action in a small amount of clear code -- not in reams of trivial code that bores the reader to death. -- Guido van Rossum
Numpy is a numerical calculus and algebra package that is widely used, notably providing the array (vector/matrix format) type used in almost all numerical projects. Documentation and Reference
Matplotlib is a module for generating 2D and 3D graphics. Documentation
It is common to import them with the respective nicknames np and plt (for matplotlib.pyplot
).
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
The last line %matplotlib inline
is a command for Jupyter to indicate that we want our figures in the notebook and not in a separate window.
x = np.array([1, 2.5, 5, 10])
print(x,type(x))
[ 1. 2.5 5. 10. ] <class 'numpy.ndarray'>
y = np.random.rand(4)
print(y,type(y))
[0.0749064 0.22495348 0.22248318 0.04446907] <class 'numpy.ndarray'>
Visualizing the data is quite simple with pyplot:
plt.figure()
plt.plot
(see the documentation )plt.savefig
plt.show()
plt.figure()
plt.plot(x,y, 'bd--', label='y(x)')
plt.legend(loc='lower right')
plt.xlabel('x')
plt.ylabel('y')
plt.title('Sample Figure')
plt.xlim([0, 10])
plt.ylim([0, 1])
plt.savefig('img/sample.png')
plt.show()
Matrices are simply 2D arrays. Since vectors and matrices share the same type, the notion of shape is very important.
M = np.array([[0.25, 6.2, 1, 10],[12, 6.2, 6, -5.3]])
print(M,type(M))
[[ 0.25 6.2 1. 10. ] [12. 6.2 6. -5.3 ]] <class 'numpy.ndarray'>
print(x,type(x))
[ 1. 2.5 5. 10. ] <class 'numpy.ndarray'>
size
of an array is the number of elements while the shape
gives how they are arranged.print(x.size) # or equivalently np.size(x)
print(M.size)
4 8
print(x.shape) # or equivalently np.shape(x)
print(M.shape)
(4,) (2, 4)
print(x)
print(x[2],x[-1])
print(x[::-1])
x[0] = 6.1554
print(x)
[ 1. 2.5 5. 10. ] 5.0 10.0 [10. 5. 2.5 1. ] [ 6.1554 2.5 5. 10. ]
v = x
w = np.copy(x)
print(v)
x[0]=1
print(v)
print(w)
[ 6.1554 2.5 5. 10. ] [ 1. 2.5 5. 10. ] [ 6.1554 2.5 5. 10. ]
print(M)
print(M[1,2],type(M[1,2]))
print(M[1,:],type(M[1,:]),M[1,:].shape)
print(M[1])
print(M[:,0])
[[ 0.25 6.2 1. 10. ] [12. 6.2 6. -5.3 ]] 6.0 <class 'numpy.float64'> [12. 6.2 6. -5.3] <class 'numpy.ndarray'> (4,) [12. 6.2 6. -5.3] [ 0.25 12. ]
Advanced access to content and modification is possible
x = np.array([1, 2.5, 5, 10])
ind = [0,2,3]
print(x[ind])
[ 1. 5. 10.]
An array has a type that can be accessed with dtype, it the combination of a base type (int, float, complex, bool, object, etc.) and a precision in bits (int64, int16, float128, complex128)
print(x.dtype)
float64
Array only accept they casting to their own type. However, the type of an array can be changed.
try:
x[0] = 1 + 2.0j
except Exception as e:
print(e)
can't convert complex to float
y = x.astype(complex)
y[0] = 1 + 2.0j
print(y,type(y),y.dtype)
[ 1. +2.j 2.5+0.j 5. +0.j 10. +0.j] <class 'numpy.ndarray'> complex128
See the corresponding documentation
arange
returns an array of evenly spaced number from start
to (at most) stop
with a fixed jump step
linspace
returns an array of evenly spaced number from start
to (exactly) stop
with a fixed number of points num
x = np.arange(0, 10, 1.5)
print(x,type(x))
[0. 1.5 3. 4.5 6. 7.5 9. ] <class 'numpy.ndarray'>
y = np.linspace(0, 10, 25)
print(y,type(y))
[ 0. 0.41666667 0.83333333 1.25 1.66666667 2.08333333 2.5 2.91666667 3.33333333 3.75 4.16666667 4.58333333 5. 5.41666667 5.83333333 6.25 6.66666667 7.08333333 7.5 7.91666667 8.33333333 8.75 9.16666667 9.58333333 10. ] <class 'numpy.ndarray'>
zeros
returns an array (of floats) of zeros of the precised shape
ones
returns an array (of floats) of ones of the precised shape
eye
returns a square 2D-array (of floats) with ones on the diagonal and zeros elsewhere
x = np.zeros(3)
print(x,x.shape,type(x),x.dtype)
x = np.zeros((3,))
print(x,x.shape,type(x),x.dtype)
[0. 0. 0.] (3,) <class 'numpy.ndarray'> float64 [0. 0. 0.] (3,) <class 'numpy.ndarray'> float64
try:
x = np.zeros(3,3) # This causes an error as 3,3 is not a shape, it is (3,3) -> double parentheses
except Exception as error:
print(error)
print(x,x.shape,type(x),x.dtype)
Cannot interpret '3' as a data type [0. 0. 0.] (3,) <class 'numpy.ndarray'> float64
x = np.zeros((3,3))
print(x,x.shape,type(x),x.dtype)
[[0. 0. 0.] [0. 0. 0.] [0. 0. 0.]] (3, 3) <class 'numpy.ndarray'> float64
y = np.ones(2)
y
array([1., 1.])
M = np.eye(3)
print(M,M.shape,type(M),M.dtype)
[[1. 0. 0.] [0. 1. 0.] [0. 0. 1.]] (3, 3) <class 'numpy.ndarray'> float64
Random arrays can be generated by Numpy's random module.
rand
returns an array (of floats) of uniformly distributed numbers in [0,1) of the precised dimension
randn
returns an array (of floats) of numbers from the normal distribution of the precised dimension
randint
returns an array (of floats) of integers from the discrete uniform distribution
np.random.rand(5)
array([0.09708256, 0.28084182, 0.03623694, 0.83693802, 0.89064811])
np.random.randn(5,2)
array([[-0.13167876, 0.53288997], [ 1.94922176, -0.55397441], [-0.8463868 , -1.96584426], [ 0.23209953, 0.58799903], [-0.08861985, 0.27334093]])
np.random.randint(0,100,size=(10,))
array([88, 6, 78, 3, 18, 17, 96, 13, 13, 90])
a = np.random.randn(10000)
plt.figure()
plt.hist(a,40) # histogram of a with 40 bins
plt.show()
v = np.arange(0, 5)
print(v)
[0 1 2 3 4]
v * 2
array([0, 2, 4, 6, 8])
v + 2.5
array([2.5, 3.5, 4.5, 5.5, 6.5])
square = v**2
root = np.sqrt(v)
print(square,root)
[ 0 1 4 9 16] [0. 1. 1.41421356 1.73205081 2. ]
plt.figure()
plt.subplot(1,2,1)
plt.plot(square,'g--', label='$y = x^2$')
plt.legend(loc=0)
plt.subplot(1,2,2)
plt.plot(root, 'r*-', label='$y = \sqrt{x}$')
plt.legend(loc=2)
plt.show()
A = np.array([[n+m*10 for n in range(5)] for m in range(4)])
print(A)
[[ 0 1 2 3 4] [10 11 12 13 14] [20 21 22 23 24] [30 31 32 33 34]]
A*2
array([[ 0, 2, 4, 6, 8], [20, 22, 24, 26, 28], [40, 42, 44, 46, 48], [60, 62, 64, 66, 68]])
A+2.5
array([[ 2.5, 3.5, 4.5, 5.5, 6.5], [12.5, 13.5, 14.5, 15.5, 16.5], [22.5, 23.5, 24.5, 25.5, 26.5], [32.5, 33.5, 34.5, 35.5, 36.5]])
Matrices can be visualized as images.
C = np.random.randn(100,100)
plt.figure()
plt.imshow(C)
plt.colorbar()
plt.show()
A = np.array([[n+m*10 for n in range(5)] for m in range(4)])
v = np.random.randint(0,5,5)
print(A,v)
[[ 0 1 2 3 4] [10 11 12 13 14] [20 21 22 23 24] [30 31 32 33 34]] [4 3 2 3 3]
A*A
array([[ 0, 1, 4, 9, 16], [ 100, 121, 144, 169, 196], [ 400, 441, 484, 529, 576], [ 900, 961, 1024, 1089, 1156]])
v*v
array([16, 9, 4, 9, 9])
A*v
array([[ 0, 3, 4, 9, 12], [ 40, 33, 24, 39, 42], [ 80, 63, 44, 69, 72], [120, 93, 64, 99, 102]])
It can be useful to transpose, it is simply done by suffixing .T
(or equivalently using the function np.transpose
). Similarly .H
is the Hermitian conjugate, .imag
.real
are the real and imaginary parts and .abs
the modulus (their full versions are respectively np.conjugate
, np.imag
, etc.)
print(A,A.shape)
print(A.T,A.T.shape)
[[ 0 1 2 3 4] [10 11 12 13 14] [20 21 22 23 24] [30 31 32 33 34]] (4, 5) [[ 0 10 20 30] [ 1 11 21 31] [ 2 12 22 32] [ 3 13 23 33] [ 4 14 24 34]] (5, 4)
$y=Av$ can be obtained by y = A.dot(v)
(or equivalently y = np.dot(A,v)
). This methods works for array with compatible shape (matrix-matrix, matrix-vector, vector-matrix, vector-vector, etc).
y = np.dot(A,v)
print(A,A.shape,v,v.shape)
print(y,type(y),y.shape)
[[ 0 1 2 3 4] [10 11 12 13 14] [20 21 22 23 24] [30 31 32 33 34]] (4, 5) [4 3 2 3 3] (5,) [ 28 178 328 478] <class 'numpy.ndarray'> (4,)
Example of vector-vector multiplication i.e. a scalar product
s = v.dot(v)
print(v, s, type(s))
[4 3 2 3 3] 47 <class 'numpy.int64'>
Example of non-compatible shapes
try:
A2 = np.dot(A,A)
except Exception as error:
print(error)
shapes (4,5) and (4,5) not aligned: 5 (dim 1) != 4 (dim 0)
A3 = np.dot(A,A.T)
print(A3,A3.shape)
[[ 30 130 230 330] [ 130 730 1330 1930] [ 230 1330 2430 3530] [ 330 1930 3530 5130]] (4, 4)
From a vector $v$, one can form the matrix $P=v v^T$ by A=v.outer(v)
(or equivalently np.outer(v,v)
)
P = np.outer(v,v)
print(P)
[[16 12 8 12 12] [12 9 6 9 9] [ 8 6 4 6 6] [12 9 6 9 9] [12 9 6 9 9]]
See the Documentation on arrays and array creation.
Warning: Modificators such as transpose, reshape, etc. do not modify the matrix, if you want to keep the result of the operation, you have to assign a variable to it. The notable exceptions are precised as in-place in the documentation.
A.reshape((2,10))
array([[ 0, 1, 2, 3, 4, 10, 11, 12, 13, 14], [20, 21, 22, 23, 24, 30, 31, 32, 33, 34]])
print(A)
[[ 0 1 2 3 4] [10 11 12 13 14] [20 21 22 23 24] [30 31 32 33 34]]
B = A.flatten()
print(B)
[ 0 1 2 3 4 10 11 12 13 14 20 21 22 23 24 30 31 32 33 34]
print(A.trace(),A.max(),A.argmax())
66 34 19
Some functions may be taken with respects to the columns with axis=0 or lines with axis=1.
print(A.mean(),A.mean(axis=0),A.mean(axis=1))
17.0 [15. 16. 17. 18. 19.] [ 2. 12. 22. 32.]
print(A.var(),A.var(axis=0),A.std(axis=1))
127.0 [125. 125. 125. 125. 125.] [1.41421356 1.41421356 1.41421356 1.41421356]
a = np.array([[1, 2], [3, 4]])
a
array([[1, 2], [3, 4]])
b = np.array([[5, 6]])
b
array([[5, 6]])
np.concatenate((a, b), axis=0)
array([[1, 2], [3, 4], [5, 6]])
np.concatenate((a, b.T), axis=1)
array([[1, 2, 5], [3, 4, 6]])
np.vstack((a,b))
array([[1, 2], [3, 4], [5, 6]])
np.hstack((a,b.T))
array([[1, 2, 5], [3, 4, 6]])
v = np.array([1,2,3,4])
for element in v:
print(element)
1 2 3 4
a = np.array([[1,2], [3,4]])
for row in a:
print("row", row)
for element in row:
print(element)
row [1 2] 1 2 row [3 4] 3 4
enumerate can be used to get indexes along with elements.
for row_idx, row in enumerate(a):
print("row_idx", row_idx, "row", row)
for col_idx, element in enumerate(row):
print("col_idx", col_idx, "element", element)
# update the matrix a: square each element
a[row_idx, col_idx] = element ** 2
row_idx 0 row [1 2] col_idx 0 element 1 col_idx 1 element 2 row_idx 1 row [3 4] col_idx 0 element 3 col_idx 1 element 4
a
array([[ 1, 4], [ 9, 16]])
Numpy comes with an efficient linear algebra module named linalg
(see the documentation ). As in many languages, the more vectorized the operations are, the more efficient.
linalg.qr
Factor the matrix $A$ as $QR$, where $Q$ is orthonormal and $R$ is upper-triangular.linalg.cholesky
Return the Cholesky decomposition, $L L^H$, of the square matrix $A$, where $L$ is lower-triangular. $A$ must be Hermitian and positive-definite. Only $L$ is actually returned.linalg.svd
Factors the matrix $A$ as $U \text{diag}(s) V$, where $U$ and $V$ are unitary and $s$ is a 1-d array of $A$‘s singular values.A = np.random.randn(3,2)
Q, R = np.linalg.qr(A)
print(A)
print(Q)
print(R)
[[-0.19169683 -0.06738807] [ 0.73213885 0.09261738] [ 0.05779475 0.20352188]] [[-0.2525575 -0.18377434] [ 0.96458118 -0.12508222] [ 0.07614366 0.97497766]] [[0.75902253 0.12185325] [0. 0.19922869]]
np.allclose(A, np.dot(Q, R)) # check that A=QR
True
U, s, V = np.linalg.svd(A)
print(U.shape, V.shape, s.shape)
(3, 3) (2, 2) (2,)
S = np.zeros(A.shape)
S[:A.shape[1], :A.shape[1]] = np.diag(s)
np.allclose(A, np.dot(U, np.dot(S, V)))
True
By default, $U$ and $V$ have the shapes $(M, M)$ and $(N, N)$ respectively if $A$ is $(M,N)$. If full_matrices=False
is passed, the shapes are $(M, K)$ and $(K, N)$, respectively, where $K = min(M, N)$.
U, s, V = np.linalg.svd(A, full_matrices=False)
print(U.shape, V.shape, s.shape)
(3, 2) (2, 2) (2,)
S = np.diag(s)
np.allclose(A, np.dot(U, np.dot(S, V)))
True
linalg.eig
compute the eigenvalues and right eigenvectors of a square array and is the main function (linalg.eigvals
computes eigenvalues of a non-symmetric array, linalg.eigh
returns eigenvalues and eigenvectors of a symmetric or Hermitian array).
A = np.array([[1, -1], [1, 1]])
print(A)
l, v = np.linalg.eig(A)
print(l); print(v)
[[ 1 -1] [ 1 1]] [1.+1.j 1.-1.j] [[0.70710678+0.j 0.70710678-0.j ] [0. -0.70710678j 0. +0.70710678j]]
A.dot(v[:,0])
array([0.70710678+0.70710678j, 0.70710678-0.70710678j])
We can check that $Ax= \lambda x$.
np.allclose(A.dot(v[:,0]),l[0]*v[:,0])
True
The function linalg.norm
is able to return one of eight different matrix norms, or one of an infinite number of vector norms (described below), depending on the value of the ord
parameter.
ord | norm for matrices | norm for vectors |
---|---|---|
None | Frobenius norm | 2-norm |
‘fro’ | Frobenius norm | – |
‘nuc’ | nuclear norm | – |
inf | max(sum(abs(x), axis=1)) | max(abs(x)) |
-inf | min(sum(abs(x), axis=1)) | min(abs(x)) |
0 | – | sum(x != 0) |
1 | max(sum(abs(x), axis=0)) | as below |
-1 | min(sum(abs(x), axis=0)) | as below |
2 | 2-norm (largest sing. value) | as below |
-2 | smallest singular value | as below |
other | – | sum(abs(x)$^{ord}$)$^{(1./ord)}$ |
a = np.arange(9) - 4
B = a.reshape((3, 3))
print(a)
print("none \t",np.linalg.norm(a))
print("2 \t",np.linalg.norm(a,ord=2))
print("1 \t",np.linalg.norm(a,ord=1))
print("inf \t",np.linalg.norm(a,ord=np.inf))
print("0 \t",np.linalg.norm(a,ord=0))
[-4 -3 -2 -1 0 1 2 3 4] none 7.745966692414834 2 7.745966692414834 1 20.0 inf 4.0 0 8.0
print(B)
print("none \t",np.linalg.norm(B))
print("2 \t",np.linalg.norm(B,ord=2))
print("1 \t",np.linalg.norm(B,ord=1))
print("inf \t",np.linalg.norm(B,ord=np.inf))
print("fro \t",np.linalg.norm(B,ord='fro'))
[[-4 -3 -2] [-1 0 1] [ 2 3 4]] none 7.745966692414834 2 7.348469228349533 1 7.0 inf 9.0 fro 7.745966692414834
Other useful function include the condition number linalg.cond
, or rank linalg.matrix_rank
.
A = np.array([[1, 0, -1], [0, 1, 0], [1, 0, 1]]) # some matrix
I = np.eye(4) # identity
Def = np.eye(4); Def[0,0]=0 # rank deficient
print(np.linalg.cond(A), np.linalg.cond(I))
1.4142135623730951 1.0
np.linalg.cond(Def)
inf
print(np.linalg.matrix_rank(A), np.linalg.matrix_rank(I), np.linalg.matrix_rank(Def))
3 4 3
When $A$ is full-rank, finding $x$ such that $Ax=b$ can be done efficiently using linalg.solve
(as a general remark it is in general bad to invert $A$ for solving such equations, although this can be done by linalg.inv
).
A = np.array([[3,1], [1,2]])
b = np.array([9,8])
print(A)
print(b)
[[3 1] [1 2]] [9 8]
x_sol = np.linalg.solve(A,b)
print(x_sol , np.allclose(A.dot(x_sol),b))
[2. 3.] True
A_inv = np.linalg.inv(A)
x_sol2 = A_inv.dot(b)
print(x_sol2 , np.allclose(A.dot(x_sol2),b))
[2. 3.] True
Why you don't want to invert a matrix except if really needed:
N= 100
A = np.random.randn(N,N)
b = np.random.randn(N)
%timeit x_sol = np.linalg.solve(A,b)
209 µs ± 68.7 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)
%timeit A_inv = np.linalg.inv(A) ; x_sol2 = A_inv.dot(b)
295 µs ± 28.3 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
If $A$ is not full-rank, the least squares solution of $Ax=b$ (i.e $x$ that minimizes $\|Ax-b\|_2$) can be obtained by linalg.lstsq
and linalg.pinv
give the Moore-Penrose pseudo inverse.
Exercise 1: In polynomial regression, we are given $n$ points $(x_i,y_i)$ and fit a size-$m$ polynome $f(x) = c_0 + c_1 x + c_2 x^2 + .. + c_m x^m$ so that $f(x_i)\approx y_i$ for all $i=1,..n$.
In this exercise, we want to find the $m+1$ coefficients $(c_j)$ that minimize the least square error $$ \left\| ~~~ \underbrace{ \left[ \begin{array}{ccccc} 1 & x_1 & x_1^2 & .. & x_1^m \\ 1 & x_2 & x_2^2 & .. & x_2^m \\ \vdots & \vdots & \vdots & \vdots & \vdots \\ 1 & x_n & x_n^2 & .. & x_n^m \end{array} \right] }_{X} ~ \underbrace{ \left[ \begin{array}{c} c_0 \\ c_1 \\ c_2 \\ \vdots \\ c_m \end{array} \right] }_{c} - \underbrace{ \left[ \begin{array}{c} y_1 \\ y_2 \\ \vdots \\ y_n \end{array} \right] }_{y} \right\|^2 $$
- Construct the matrix $X$ from the given vector $x$ below with $m=3$.
- Find the optimal $c$ by solving the least square problem $\min_c \|Xc-y\|^2$ using Numpy (
lstsq
andsolve
). Is the result exact (no error)?- Plot the obtained polynome on the scatter plot.
- Redo questions 2-3 by varying the relative sizes of $n$ and $m$. What do you observe?
import numpy as np
n = 30 # Number of sample points
x = (np.random.rand(n)-0.5)*6
y = np.sign(x)*np.maximum(np.abs(x)-1.0,0.0)
import matplotlib.pyplot as plt
plt.scatter(x,y)
<matplotlib.collections.PathCollection at 0x7f989da986a0>