Help on package numpy:

NAME
numpy

DESCRIPTION
NumPy
=====

Provides
1. An array object of arbitrary homogeneous items
2. Fast mathematical operations over arrays
3. Linear Algebra, Fourier Transforms, Random Number Generation

How to use the documentation

----------------------------
Documentation is available in two forms: docstrings provided
with the code, and a loose standing reference guide, available from
`the NumPy homepage <https://numpy.org>`_.

We recommend exploring the docstrings using

`IPython <https://ipython.org>`_, an advanced Python shell with
TAB-completion and introspection capabilities. See below for further
instructions.

The docstring examples assume that `numpy` has been imported as ``np``::

>>> import numpy as np

Code snippets are indicated by three greater-than signs::

>>> x = 42
>>> x = x + 1

Use the built-in ``help`` function to view a function's docstring::

>>> help(np.sort)
... # doctest: +SKIP

For some objects, ``np.info(obj)`` may provide additional help. This is

particularly true if you see the line "Help on ufunc object:" at the top
of the help() page. Ufuncs are implemented in C, not Python, for speed.
The native Python help() does not know how to view their help, but our
np.info() function does.

To search for documents containing a keyword, do::

>>> np.lookfor('keyword')
... # doctest: +SKIP

General-purpose documents like a glossary and help on the basic concepts

of numpy are available under the ``doc`` sub-module::

>>> from numpy import doc

>>> help(doc)
... # doctest: +SKIP

Available subpackages
---------------------
 lib
Basic functions used by several sub-packages.
random
Core Random Tools
linalg
Core Linear Algebra Tools
fft
Core FFT routines
polynomial
Polynomial tools
testing
NumPy testing tools
distutils
Enhancements to distutils with support for
Fortran compilers support and more (for Python <= 3.11).

Utilities
---------
test
Run numpy unittests
show_config
Show numpy build configuration
matlib
Make everything matrices.
__version__
NumPy version string

Viewing documentation using IPython

-----------------------------------

Start IPython and import `numpy` usually under the alias ``np``: `import
numpy as np`. Then, directly past or use the ``%cpaste`` magic to paste
examples into the shell. To see which functions are available in `numpy`,
type ``np.<TAB>`` (where ``<TAB>`` refers to the TAB key), or use
``np.*cos*?<ENTER>`` (where ``<ENTER>`` refers to the ENTER key) to narrow
down the list. To view the docstring for a function, use
``np.cos?<ENTER>`` (to view the docstring) and ``np.cos??<ENTER>`` (to view
the source code).

Copies vs. in-place operation

-----------------------------
Most of the functions in `numpy` return a copy of the array argument
(e.g., `np.sort`). In-place versions of these functions are often
available as array methods, i.e. ``x = np.array([1,2,3]); x.sort()``.
Exceptions to this rule are documented.

PACKAGE CONTENTS
__config__
_core (package)
_distributor_init
_globals
_pyinstaller (package)
_pytesttester
_typing (package)
_utils (package)
array_api (package)
compat (package)
conftest
core (package)
 ctypeslib
distutils (package)
doc (package)
dtypes
exceptions
f2py (package)
fft (package)
lib (package)
linalg (package)
ma (package)
matlib
matrixlib (package)
polynomial (package)
random (package)
testing (package)
tests (package)
typing (package)
version

SUBMODULES
_mat
char
emath
rec

CLASSES
builtins.UserWarning(builtins.Warning)
RankWarning
builtins.bytes(builtins.object)
bytes_(builtins.bytes, character)
builtins.object
DataSource
broadcast
busdaycalendar
dtype
finfo
flatiter
format_parser
generic
bool_
datetime64
flexible
character
bytes_(builtins.bytes, character)
str_(builtins.str, character)
void
record
number
inexact
complexfloating
clongdouble
complex128(complexfloating, builtins.complex)
complex64
floating
float16
float32
float64(floating, builtins.float)
longdouble
integer
 signedinteger
int16
int32
int64
int8
intc
timedelta64
unsignedinteger
uint16
uint32
uint64
uint8
uintc
object_
iinfo
ndarray
chararray
matrix
memmap
recarray
ndenumerate
ndindex
nditer
poly1d
ufunc
vectorize
builtins.str(builtins.object)
str_(builtins.str, character)
contextlib.ContextDecorator(builtins.object)
errstate

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 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).
|
| add_note(...)
| Exception.add_note(note) --
| add a note to the exception
|
| 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 bool_(generic)
| Boolean type (True or False), stored as a byte.
|
| .. warning::
|
| The :class:`bool_` type is not a subclass of the :class:`int_` type
| (the :class:`bool_` is not even a number type). This is different
| than Python's default implementation of :class:`bool` as a
| sub-class of :class:`int`.
|
| :Character code: ``'?'``
|
| Method resolution order:
| bool_
| generic
| builtins.object
|
| Methods defined here:
|
| __and__(self, value, /)
| Return self&value.
|
| __bool__(self, /)
| True if self else False
|
| __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(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.all`.
|
| any(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.any`.
|
| argmax(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmax`.
|
| argmin(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmin`.
|
| argsort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argsort`.
|
| astype(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.astype`.
|
| byteswap(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.byteswap`.
|
| choose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.choose`.
|
| clip(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.clip`.
|
| compress(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.compress`.
|
| conj(...)
|
| conjugate(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.conjugate`.
|
| copy(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.copy`.
|
| cumprod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumprod`.
|
| cumsum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumsum`.
|
| diagonal(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.diagonal`.
|
| dump(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dump`.
|
| dumps(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dumps`.
|
| fill(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.fill`.
|
| flatten(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.flatten`.
|
| getfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.getfield`.
|
| item(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.item`.
|
| itemset(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.itemset`.
|
| max(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.max`.
|
| mean(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.mean`.
|
| min(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.min`.
|
| newbyteorder(...)
| newbyteorder(new_order='S', /)
|
| Return a new `dtype` with a different byte order.
|
| Changes are also made in all fields and sub-arrays of the data type.
|
| The `new_order` code can be any from the following:
|
| * 'S' - swap dtype from current to opposite endian
| * {'<', 'little'} - little endian
| * {'>', 'big'} - big endian
| * {'=', 'native'} - 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.
|
|
| Returns
| -------
| new_dtype : dtype
| New `dtype` object with the given change to the byte order.
|
| nonzero(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.nonzero`.
|
| prod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.prod`.
|
| ptp(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ptp`.
|
| put(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.put`.
|
| ravel(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ravel`.
|
| repeat(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.repeat`.
|
| reshape(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.reshape`.
|
| resize(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.resize`.
|
| round(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.round`.
|
| searchsorted(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.searchsorted`.
|
| setfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setfield`.
|
| setflags(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setflags`.
|
| sort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sort`.
|
| squeeze(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.squeeze`.
|
| std(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.std`.
|
| sum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sum`.
|
| swapaxes(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.swapaxes`.
|
| take(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.take`.
|
| tobytes(...)
|
| tofile(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tofile`.
|
| tolist(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tolist`.
|
| tostring(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tostring`.
|
| trace(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.trace`.
|
| transpose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.transpose`.
|
| var(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.var`.
|
| view(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.view`.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from generic:
|
| T
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.T`.
|
| __array_interface__
| Array protocol: Python side
|
| __array_priority__
| Array priority.
|
| __array_struct__
| Array protocol: struct
|
| base
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.base`.
|
| data
| Pointer to start of data.
|
| dtype
| Get array data-descriptor.
|
| flags
| The integer value of flags.
|
| flat
| A 1-D view of the scalar.
|
| imag
| The imaginary part of the scalar.
|
| itemsize
| The length of one element in bytes.
|
| nbytes
| The length of the scalar in bytes.
|
| ndim
| The number of array dimensions.
|
| real
| The real part of the scalar.
|
| shape
| Tuple of array dimensions.
|
| size
| The 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
| broadcast_shapes
|
| 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: `numpy.byte`
| :Alias on this platform (win32 AMD64): `numpy.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, /)
 | True if self else False
|
| __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.
|
| bit_count(...)
| int8.bit_count() -> int
|
| Computes the number of 1-bits in the absolute value of the input.
| Analogous to the builtin `int.bit_count` or ``popcount`` in C++.
|
| Examples
| --------
| >>> np.int8(127).bit_count()
| 7
| >>> np.int8(-127).bit_count()
| 7
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| __class_getitem__(...) from builtins.type
| __class_getitem__(item, /)
|
| Return a parametrized wrapper around the `~numpy.number` type.
|
| .. versionadded:: 1.22
|
| Returns
| -------
| alias : types.GenericAlias
| A parametrized `~numpy.number` type.
|
| Examples
| --------
| >>> from typing import Any
| >>> import numpy as np
|
| >>> np.signedinteger[Any]
| numpy.signedinteger[typing.Any]
|
| See Also
| --------
| :pep:`585` : Type hinting generics in standard collections.
|
| ----------------------------------------------------------------------
| 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__(...)
|
| is_integer(...)
| integer.is_integer() -> bool
|
| Return ``True`` if the number is finite with integral value.
|
| .. versionadded:: 1.22
|
| Examples
| --------
| >>> np.int64(-2).is_integer()
| True
| >>> np.uint32(5).is_integer()
| True
|
| ----------------------------------------------------------------------
| 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(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.all`.
|
| any(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.any`.
|
| argmax(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmax`.
|
| argmin(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmin`.
|
| argsort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argsort`.
|
| astype(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.astype`.
|
| byteswap(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.byteswap`.
|
| choose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.choose`.
|
| clip(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.clip`.
|
| compress(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.compress`.
|
| conj(...)
|
| conjugate(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.conjugate`.
|
| copy(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.copy`.
|
| cumprod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumprod`.
|
| cumsum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumsum`.
|
| diagonal(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.diagonal`.
|
| dump(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dump`.
|
| dumps(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dumps`.
|
| fill(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.fill`.
|
| flatten(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.flatten`.
|
| getfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.getfield`.
|
| item(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.item`.
|
| itemset(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.itemset`.
|
| max(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.max`.
|
| mean(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.mean`.
|
| min(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.min`.
|
| newbyteorder(...)
| newbyteorder(new_order='S', /)
|
| Return a new `dtype` with a different byte order.
|
| Changes are also made in all fields and sub-arrays of the data type.
|
| The `new_order` code can be any from the following:
|
| * 'S' - swap dtype from current to opposite endian
| * {'<', 'little'} - little endian
| * {'>', 'big'} - big endian
| * {'=', 'native'} - 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.
|
|
| Returns
| -------
| new_dtype : dtype
| New `dtype` object with the given change to the byte order.
|
| nonzero(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.nonzero`.
|
| prod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.prod`.
|
| ptp(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ptp`.
|
| put(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.put`.
|
| ravel(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ravel`.
|
| repeat(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.repeat`.
|
| reshape(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.reshape`.
|
| resize(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.resize`.
|
| round(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.round`.
|
| searchsorted(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.searchsorted`.
|
| setfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setfield`.
|
| setflags(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setflags`.
|
| sort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sort`.
|
| squeeze(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.squeeze`.
|
| std(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.std`.
|
| sum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sum`.
|
| swapaxes(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.swapaxes`.
|
| take(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.take`.
|
| tobytes(...)
|
| tofile(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tofile`.
|
| tolist(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tolist`.
|
| tostring(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tostring`.
|
| trace(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.trace`.
|
| transpose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.transpose`.
|
| var(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.var`.
|
| view(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.view`.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from generic:
|
| T
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.T`.
|
| __array_interface__
| Array protocol: Python side
|
| __array_priority__
| Array priority.
|
| __array_struct__
| Array protocol: struct
|
| base
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.base`.
|
| data
| Pointer to start of data.
|
| dtype
| Get array data-descriptor.
|
| flags
| The integer value of flags.
|
| flat
| A 1-D view of the scalar.
|
| imag
| The imaginary part of the scalar.
|
| itemsize
| The length of one element in bytes.
|
| nbytes
| The length of the scalar in bytes.
|
| ndim
| The number of array dimensions.
|
| real
| The real part of the scalar.
|
| shape
| Tuple of array dimensions.
|
| size
| The number of elements in the gentype.
|
| strides
| Tuple of bytes steps in each dimension.

class bytes_(builtins.bytes, character)

| A byte string.
|
| When used in arrays, this type strips trailing null bytes.
|
| :Character code: ``'S'``
| :Alias: `numpy.string_`
|
| 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.
|
| __bytes__(self, /)
| Convert this value to exact type bytes.
|
| __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 string 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.
|
| removeprefix(self, prefix, /)
| Return a bytes object with the given prefix string removed if present.
|
| If the bytes starts with the prefix string, return bytes[len(prefix):].
| Otherwise, return a copy of the original bytes.
|
| removesuffix(self, suffix, /)
| Return a bytes object with the given suffix string removed if present.
 |
| If the bytes ends with the suffix string and that suffix is not empty,
| return bytes[:-len(prefix)]. Otherwise, return a copy of the original
| bytes.
|
| 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, /)
| True if self else False
|
| __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(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.all`.
|
| any(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.any`.
|
| argmax(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmax`.
|
| argmin(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmin`.
|
| argsort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argsort`.
|
| astype(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.astype`.
|
| byteswap(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.byteswap`.
|
| choose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.choose`.
|
| clip(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.clip`.
|
| compress(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.compress`.
|
| conj(...)
|
| conjugate(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.conjugate`.
|
| copy(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.copy`.
|
| cumprod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumprod`.
|
| cumsum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumsum`.
|
| diagonal(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.diagonal`.
|
| dump(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dump`.
|
| dumps(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dumps`.
|
| fill(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.fill`.
|
| flatten(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.flatten`.
|
| getfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.getfield`.
|
| item(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.item`.
|
| itemset(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.itemset`.
|
| max(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.max`.
|
| mean(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.mean`.
|
| min(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.min`.
|
| newbyteorder(...)
| newbyteorder(new_order='S', /)
|
| Return a new `dtype` with a different byte order.
|
| Changes are also made in all fields and sub-arrays of the data type.
|
| The `new_order` code can be any from the following:
|
| * 'S' - swap dtype from current to opposite endian
| * {'<', 'little'} - little endian
| * {'>', 'big'} - big endian
| * {'=', 'native'} - 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.
|
|
| Returns
| -------
| new_dtype : dtype
| New `dtype` object with the given change to the byte order.
|
| nonzero(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.nonzero`.
|
| prod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.prod`.
|
| ptp(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ptp`.
|
| put(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.put`.
|
| ravel(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ravel`.
|
| repeat(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.repeat`.
|
| reshape(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.reshape`.
|
| resize(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.resize`.
|
| round(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.round`.
|
| searchsorted(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.searchsorted`.
|
| setfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setfield`.
|
| setflags(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setflags`.
|
| sort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sort`.
|
| squeeze(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.squeeze`.
|
| std(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.std`.
|
| sum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sum`.
|
| swapaxes(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.swapaxes`.
|
| take(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.take`.
|
| tobytes(...)
|
| tofile(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tofile`.
|
| tolist(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tolist`.
|
| tostring(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tostring`.
|
| trace(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.trace`.
|
| transpose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.transpose`.
|
| var(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.var`.
|
| view(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.view`.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from generic:
|
| T
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.T`.
|
| __array_interface__
| Array protocol: Python side
|
| __array_priority__
| Array priority.
|
| __array_struct__
| Array protocol: struct
|
| base
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.base`.
|
| data
| Pointer to start of data.
|
| dtype
| Get array data-descriptor.
|
| flags
| The integer value of flags.
|
| flat
| A 1-D view of the scalar.
|
| imag
| The imaginary part of the scalar.
|
| itemsize
| The length of one element in bytes.
|
| nbytes
 | The length of the scalar in bytes.
|
| ndim
| The number of array dimensions.
|
| real
| The real part of the scalar.
|
| shape
| Tuple of array dimensions.
|
| size
| The 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: `numpy.cdouble`
| :Alias: `numpy.cfloat`
| :Alias: `numpy.complex_`
| :Alias on this platform (win32 AMD64): `numpy.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, /)
| True if self else False
|
| __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.
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| __class_getitem__(...) from builtins.type
| __class_getitem__(item, /)
|
| Return a parametrized wrapper around the `~numpy.number` type.
|
| .. versionadded:: 1.22
|
| Returns
| -------
| alias : types.GenericAlias
| A parametrized `~numpy.number` type.
|
| Examples
| --------
| >>> from typing import Any
| >>> import numpy as np
|
| >>> np.signedinteger[Any]
| numpy.signedinteger[typing.Any]
|
| See Also
| --------
| :pep:`585` : Type hinting generics in standard collections.
|
| ----------------------------------------------------------------------
| 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__(...)
|
| __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(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.all`.
|
| any(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.any`.
|
| argmax(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmax`.
|
| argmin(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmin`.
|
| argsort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argsort`.
|
| astype(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.astype`.
|
| byteswap(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.byteswap`.
|
| choose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.choose`.
|
| clip(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.clip`.
|
| compress(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.compress`.
|
| conj(...)
|
| conjugate(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.conjugate`.
|
| copy(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.copy`.
|
| cumprod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumprod`.
|
| cumsum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumsum`.
|
| diagonal(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.diagonal`.
|
| dump(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dump`.
|
| dumps(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dumps`.
|
| fill(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.fill`.
|
| flatten(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.flatten`.
|
| getfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.getfield`.
|
| item(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.item`.
|
| itemset(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.itemset`.
|
| max(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.max`.
|
| mean(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.mean`.
|
| min(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.min`.
|
| newbyteorder(...)
| newbyteorder(new_order='S', /)
|
| Return a new `dtype` with a different byte order.
|
| Changes are also made in all fields and sub-arrays of the data type.
|
| The `new_order` code can be any from the following:
|
| * 'S' - swap dtype from current to opposite endian
| * {'<', 'little'} - little endian
| * {'>', 'big'} - big endian
| * {'=', 'native'} - 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.
|
|
| Returns
| -------
| new_dtype : dtype
| New `dtype` object with the given change to the byte order.
|
| nonzero(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.nonzero`.
|
| prod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.prod`.
|
| ptp(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ptp`.
|
| put(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.put`.
|
| ravel(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ravel`.
|
| repeat(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.repeat`.
|
| reshape(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.reshape`.
|
| resize(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.resize`.
|
| round(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.round`.
|
| searchsorted(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.searchsorted`.
|
| setfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setfield`.
|
| setflags(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setflags`.
|
| sort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sort`.
|
| squeeze(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.squeeze`.
|
| std(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.std`.
|
| sum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sum`.
|
| swapaxes(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.swapaxes`.
|
| take(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.take`.
|
| tobytes(...)
|
| tofile(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tofile`.
|
| tolist(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tolist`.
|
| tostring(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tostring`.
|
| trace(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.trace`.
|
| transpose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.transpose`.
|
| var(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.var`.
|
| view(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.view`.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from generic:
|
| T
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.T`.
|
| __array_interface__
| Array protocol: Python side
|
| __array_priority__
| Array priority.
|
| __array_struct__
| Array protocol: struct
|
| base
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.base`.
|
| data
| Pointer to start of data.
|
| dtype
| Get array data-descriptor.
|
| flags
| The integer value of flags.
|
| flat
| A 1-D view of the scalar.
|
| imag
| The imaginary part of the scalar.
|
| itemsize
| The length of one element in bytes.
|
| nbytes
| The length of the scalar in bytes.
|
| ndim
| The number of array dimensions.
|
| real
| The real part of the scalar.
|
| shape
| Tuple of array dimensions.
|
| size
| The number of elements in the gentype.
|
| strides
| Tuple of bytes steps in each dimension.
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.complex:
|
| __complex__(self, /)
| Convert this value to exact type complex.
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __getnewargs__(self, /)

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: `numpy.cdouble`
| :Alias: `numpy.cfloat`
| :Alias: `numpy.complex_`
| :Alias on this platform (win32 AMD64): `numpy.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, /)
| True if self else False
|
| __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.
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| __class_getitem__(...) from builtins.type
| __class_getitem__(item, /)
|
| Return a parametrized wrapper around the `~numpy.number` type.
|
| .. versionadded:: 1.22
|
| Returns
| -------
| alias : types.GenericAlias
| A parametrized `~numpy.number` type.
|
| Examples
| --------
| >>> from typing import Any
| >>> import numpy as np
|
| >>> np.signedinteger[Any]
| numpy.signedinteger[typing.Any]
|
| See Also
| --------
| :pep:`585` : Type hinting generics in standard collections.
|
| ----------------------------------------------------------------------
| 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__(...)
|
| __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(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.all`.
|
| any(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.any`.
|
| argmax(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmax`.
|
| argmin(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmin`.
|
| argsort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argsort`.
|
| astype(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.astype`.
|
| byteswap(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.byteswap`.
|
| choose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.choose`.
|
| clip(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.clip`.
|
| compress(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.compress`.
|
| conj(...)
|
| conjugate(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.conjugate`.
|
| copy(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.copy`.
|
| cumprod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumprod`.
|
| cumsum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumsum`.
|
| diagonal(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.diagonal`.
|
| dump(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dump`.
|
| dumps(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dumps`.
|
| fill(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.fill`.
|
| flatten(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.flatten`.
|
| getfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.getfield`.
|
| item(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.item`.
|
| itemset(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.itemset`.
|
| max(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.max`.
|
| mean(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.mean`.
|
| min(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.min`.
|
| newbyteorder(...)
| newbyteorder(new_order='S', /)
|
| Return a new `dtype` with a different byte order.
|
| Changes are also made in all fields and sub-arrays of the data type.
|
| The `new_order` code can be any from the following:
|
| * 'S' - swap dtype from current to opposite endian
| * {'<', 'little'} - little endian
| * {'>', 'big'} - big endian
| * {'=', 'native'} - 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.
|
|
| Returns
| -------
| new_dtype : dtype
| New `dtype` object with the given change to the byte order.
|
| nonzero(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.nonzero`.
|
| prod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.prod`.
|
| ptp(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ptp`.
|
| put(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.put`.
|
| ravel(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ravel`.
|
| repeat(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.repeat`.
|
| reshape(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.reshape`.
|
| resize(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.resize`.
|
| round(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.round`.
|
| searchsorted(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.searchsorted`.
|
| setfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setfield`.
|
| setflags(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setflags`.
|
| sort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sort`.
|
| squeeze(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.squeeze`.
|
| std(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.std`.
|
| sum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sum`.
|
| swapaxes(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.swapaxes`.
|
| take(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.take`.
|
| tobytes(...)
|
| tofile(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tofile`.
|
| tolist(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tolist`.
|
| tostring(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tostring`.
|
| trace(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.trace`.
|
| transpose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.transpose`.
|
| var(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.var`.
|
| view(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.view`.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from generic:
|
| T
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.T`.
|
| __array_interface__
| Array protocol: Python side
|
| __array_priority__
| Array priority.
|
| __array_struct__
| Array protocol: struct
|
| base
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.base`.
|
| data
| Pointer to start of data.
|
| dtype
| Get array data-descriptor.
|
| flags
| The integer value of flags.
|
| flat
| A 1-D view of the scalar.
|
| imag
| The imaginary part of the scalar.
|
| itemsize
| The length of one element in bytes.
|
| nbytes
 | The length of the scalar in bytes.
|
| ndim
| The number of array dimensions.
|
| real
| The real part of the scalar.
|
| shape
| Tuple of array dimensions.
|
| size
| The number of elements in the gentype.
|
| strides
| Tuple of bytes steps in each dimension.
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.complex:
|
| __complex__(self, /)
| Convert this value to exact type complex.
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __getnewargs__(self, /)

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, /)
| True if self else False
|
| __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(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.all`.
|
| any(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.any`.
|
| argmax(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmax`.
|
| argmin(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmin`.
|
| argsort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argsort`.
|
| astype(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.astype`.
|
| byteswap(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.byteswap`.
|
| choose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.choose`.
|
| clip(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.clip`.
|
| compress(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.compress`.
|
| conj(...)
|
| conjugate(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.conjugate`.
|
| copy(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.copy`.
|
| cumprod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumprod`.
|
| cumsum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumsum`.
|
| diagonal(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.diagonal`.
|
| dump(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dump`.
|
| dumps(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dumps`.
|
| fill(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.fill`.
|
| flatten(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.flatten`.
|
| getfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.getfield`.
|
| item(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.item`.
|
| itemset(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.itemset`.
|
| max(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.max`.
|
| mean(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.mean`.
|
| min(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.min`.
|
| newbyteorder(...)
| newbyteorder(new_order='S', /)
|
| Return a new `dtype` with a different byte order.
|
| Changes are also made in all fields and sub-arrays of the data type.
|
| The `new_order` code can be any from the following:
|
| * 'S' - swap dtype from current to opposite endian
| * {'<', 'little'} - little endian
| * {'>', 'big'} - big endian
| * {'=', 'native'} - 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.
|
|
| Returns
| -------
| new_dtype : dtype
| New `dtype` object with the given change to the byte order.
|
| nonzero(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.nonzero`.
|
| prod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.prod`.
|
| ptp(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ptp`.
|
| put(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.put`.
|
| ravel(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ravel`.
|
| repeat(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.repeat`.
|
| reshape(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.reshape`.
|
| resize(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.resize`.
|
| round(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.round`.
|
| searchsorted(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.searchsorted`.
|
| setfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setfield`.
|
| setflags(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setflags`.
|
| sort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sort`.
|
| squeeze(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.squeeze`.
|
| std(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.std`.
|
| sum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sum`.
|
| swapaxes(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.swapaxes`.
|
| take(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.take`.
|
| tobytes(...)
|
| tofile(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tofile`.
|
| tolist(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tolist`.
|
| tostring(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tostring`.
|
| trace(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.trace`.
|
| transpose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.transpose`.
|
| var(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.var`.
|
| view(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.view`.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from generic:
|
| T
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.T`.
|
| __array_interface__
| Array protocol: Python side
 |
| __array_priority__
| Array priority.
|
| __array_struct__
| Array protocol: struct
|
| base
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.base`.
|
| data
| Pointer to start of data.
|
| dtype
| Get array data-descriptor.
|
| flags
| The integer value of flags.
|
| flat
| A 1-D view of the scalar.
|
| imag
| The imaginary part of the scalar.
|
| itemsize
| The length of one element in bytes.
|
| nbytes
| The length of the scalar in bytes.
|
| ndim
| The number of array dimensions.
|
| real
| The real part of the scalar.
|
| shape
| Tuple of array dimensions.
|
| size
| The 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_`, `bytes_` or `str_`, 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)
| a.__array_finalize__(obj, /)
|
| Present so subclasses can call super. Does nothing.
|
| __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 `bytes_`
| or `str_`.
|
| 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 `bytes_` or `str_`.
|
| 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 ``bytes.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], /)
|
| 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__(array[, context], /)
|
| Returns a view of `array` with the same type as self.
|
| __array_ufunc__(...)
|
| __array_wrap__(...)
| a.__array_wrap__(array[, context], /)
|
| Returns a view of `array` with the same type as self.
|
| __bool__(self, /)
| True if self else False
|
| __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, /)
|
| Used if :func:`copy.deepcopy` is called on an array.
|
| __delitem__(self, key, /)
| Delete self[key].
|
| __divmod__(self, value, /)
| Return divmod(self, value).
|
| __dlpack__(...)
| a.__dlpack__(*, stream=None)
|
| DLPack Protocol: Part of the Array API.
|
| __dlpack_device__(...)
| a.__dlpack_device__()
|
| DLPack Protocol: Part of the Array API.
 |
| __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, *, where=True)
|
| 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, *, where=True)
|
| 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, *, keepdims=False)
|
| 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, *, keepdims=False)
|
| Return indices of the minimum values along the given axis.
|
| 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, and this function always passes sub-classes through.)
|
| See also
| --------
| numpy.copy : Similar function with different default behavior
| numpy.copyto
|
| Notes
| -----
| This function is the preferred method for creating an array copy. The
| function :func:`numpy.copy` is similar, but it defaults to using order
'K',
| and will not pass sub-classes through by default.
|
| 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(...)
|
| 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 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.])
|
| Fill expects a scalar value and always behaves the same as assigning
| to a single array element. The following is a rare example where this
| distinction is important:
|
| >>> a = np.array([None, None], dtype=object)
| >>> a[0] = np.array(3)
| >>> a
| array([array(3), None], dtype=object)
| >>> a.fill(np.array(3))
| >>> a
| array([array(3), array(3)], dtype=object)
|
| Where other forms of assignments will unpack the array being assigned:
|
| >>> a[...] = np.array(3)
| >>> a
| array([3, 3], dtype=object)
|
| 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, *, where=True)
|
| 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
| * {'<', 'little'} - little endian
| * {'>', 'big'} - big endian
| * {'=', 'native'} - native order, equivalent to `sys.byteorder`
| * {'|', 'I'} - ignore (no change to byte order)
|
| The default value ('S') results in swapping the current
| byte order.
|
|
| 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,
| 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 flag can never be set
| to True. The flag WRITEABLE can only be set to True if the array owns
its
| own memory, or the ultimate owner of the memory exposes a writeable
buffer
| interface, or is a string. (The exception for string is made so that
| unpickling can be done without copying memory.)
|
| Parameters
| ----------
| write : bool, optional
| Describes whether or not `a` can be written to.
| align : bool, optional
| Describes whether or not `a` is aligned properly for its type.
| uic : bool, optional
| Describes whether or not `a` is a copy of another "base" array.
|
| Notes
| -----
| Array flags provide information about how the memory area used
| for the array is to be interpreted. There are 7 Boolean flags
| in use, only four of which can be changed by the user:
| WRITEBACKIFCOPY, 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);
|
| 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
| >>> y.setflags(write=0, align=0)
| >>> y.flags
| C_CONTIGUOUS : True
| F_CONTIGUOUS : False
| OWNDATA : True
 | WRITEABLE : False
| ALIGNED : False
| WRITEBACKIFCOPY : 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 axes of length one from `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, *,
where=True)
|
| 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 is produced in C-order by default.
| This behavior is controlled by the ``order`` parameter.
|
| .. versionadded:: 1.9.0
|
| Parameters
| ----------
| order : {'C', 'F', 'A'}, optional
| Controls the memory layout of the bytes object. 'C' means C-order,
| 'F' means F-order, 'A' (short for *Any*) means 'F' if `a` is
| Fortran contiguous, 'C' otherwise. Default is 'C'.
|
| Returns
| -------
| s : bytes
| Python bytes exhibiting a copy of `a`'s raw data.
|
| See also
| --------
| frombuffer
| Inverse of this operation, construct a 1-dimensional array from
Python
| bytes.
|
| 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.
|
| Refer to `numpy.transpose` for full documentation.
|
| 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 that the
| array's `i`-th axis becomes the transposed array'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
| -------
| p : ndarray
| View of the array with its axes suitably permuted.
|
| See Also
| --------
| transpose : Equivalent function.
| 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]])
|
| >>> a = np.array([1, 2, 3, 4])
| >>> a
| array([1, 2, 3, 4])
| >>> a.transpose()
| array([1, 2, 3, 4])
|
| var(...)
| a.var(axis=None, dtype=None, out=None, ddof=0, keepdims=False, *,
where=True)
|
| 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 last axis of ``a`` must be
| contiguous. This axis will be resized in the result.
|
| .. versionchanged:: 1.23.0
| Only the last axis needs to be contiguous. Previously, the entire
array
| had to be C-contiguous.
|
| 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[:, ::2]
| >>> y
| array([[1, 3],
| [4, 6]], 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 last axis
must be contiguous
| >>> z = y.copy()
| >>> z.view(dtype=[('width', np.int16), ('length', np.int16)])
| array([[(1, 3)],
| [(4, 6)]], dtype=[('width', '<i2'), ('length', '<i2')])
|
| However, views that change dtype are totally fine for arrays with a
 | contiguous last axis, even if the rest of the axes are not C-
contiguous:
|
| >>> x = np.arange(2 * 3 * 4, dtype=np.int8).reshape(2, 3, 4)
| >>> x.transpose(1, 0, 2).view(np.int16)
| array([[[ 256, 770],
| [3340, 3854]],
| <BLANKLINE>
| [[1284, 1798],
| [4368, 4882]],
| <BLANKLINE>
| [[2312, 2826],
| [5396, 5910]]], dtype=int16)
|
| ----------------------------------------------------------------------
| Class methods inherited from ndarray:
|
| __class_getitem__(...) from builtins.type
| a.__class_getitem__(item, /)
|
| Return a parametrized wrapper around the `~numpy.ndarray` type.
|
| .. versionadded:: 1.22
|
| Returns
| -------
| alias : types.GenericAlias
| A parametrized `~numpy.ndarray` type.
|
| Examples
| --------
| >>> from typing import Any
| >>> import numpy as np
|
| >>> np.ndarray[Any, np.dtype[Any]]
| numpy.ndarray[typing.Any, numpy.dtype[typing.Any]]
|
| See Also
| --------
| :pep:`585` : Type hinting generics in standard collections.
| numpy.typing.NDArray : An ndarray alias :term:`generic <generic type>`
| w.r.t. its `dtype.type <numpy.dtype.type>`.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from ndarray:
|
| T
| View of the transposed array.
|
| Same as ``self.transpose()``.
|
| Examples
| --------
| >>> a = np.array([[1, 2], [3, 4]])
| >>> a
| array([[1, 2],
| [3, 4]])
| >>> a.T
| array([[1, 3],
| [2, 4]])
|
| >>> a = np.array([1, 2, 3, 4])
| >>> a
| array([1, 2, 3, 4])
| >>> a.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.
 |
| .. warning::
|
| Setting ``arr.dtype`` is discouraged and may be deprecated in the
| future. Setting will replace the ``dtype`` without modifying the
| memory (see also `ndarray.view` and `ndarray.astype`).
|
| Parameters
| ----------
| None
|
| Returns
| -------
| d : numpy dtype object
|
| See Also
| --------
| ndarray.astype : Cast the values contained in the array to a new data-
type.
| ndarray.view : Create a view of the same data but a different data-
type.
| 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.
| 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, 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:
|
| - 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.
|
| See Also
| --------
| sys.getsizeof
| Memory consumed by the object itself without parents in case view.
| This does include memory consumed by non-element attributes.
|
| 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.
|
| .. warning::
|
| Setting ``arr.shape`` is discouraged and may be deprecated in the
| future. Using `ndarray.reshape` is the preferred approach.
|
| 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.shape : Equivalent getter function.
| numpy.reshape : Function similar to setting ``shape``.
| ndarray.reshape : Method similar to setting ``shape``.
|
| 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.
|
| .. warning::
|
| Setting ``arr.strides`` is discouraged and may be deprecated in the
| future. `numpy.lib.stride_tricks.as_strided` should be preferred
| to create a new view of the same data in a safer way.
|
| 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

class clongdouble(complexfloating)
| Complex number type composed of two extended-precision floating-point
| numbers.
|
| :Character code: ``'G'``
| :Alias: `numpy.clongfloat`
| :Alias: `numpy.longcomplex`
|
| Method resolution order:
| clongdouble
| complexfloating
| inexact
| number
| generic
| builtins.object
|
| Methods defined here:
|
| __abs__(self, /)
| abs(self)
|
| __add__(self, value, /)
| Return self+value.
|
| __bool__(self, /)
| True if self else False
|
| __complex__(...)
|
| __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.
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| __class_getitem__(...) from builtins.type
| __class_getitem__(item, /)
|
| Return a parametrized wrapper around the `~numpy.number` type.
|
| .. versionadded:: 1.22
|
| Returns
| -------
| alias : types.GenericAlias
| A parametrized `~numpy.number` type.
|
| Examples
| --------
| >>> from typing import Any
| >>> import numpy as np
|
| >>> np.signedinteger[Any]
| numpy.signedinteger[typing.Any]
|
| See Also
| --------
| :pep:`585` : Type hinting generics in standard collections.
|
| ----------------------------------------------------------------------
| 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__(...)
|
| __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(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.all`.
|
| any(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.any`.
|
| argmax(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmax`.
|
| argmin(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmin`.
|
| argsort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argsort`.
|
| astype(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.astype`.
|
| byteswap(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.byteswap`.
|
| choose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.choose`.
|
| clip(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.clip`.
|
| compress(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.compress`.
|
| conj(...)
|
| conjugate(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.conjugate`.
|
| copy(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.copy`.
|
| cumprod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumprod`.
|
| cumsum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumsum`.
|
| diagonal(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.diagonal`.
|
| dump(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dump`.
|
| dumps(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dumps`.
|
| fill(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.fill`.
|
| flatten(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.flatten`.
|
| getfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.getfield`.
|
| item(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.item`.
|
| itemset(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.itemset`.
|
| max(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.max`.
|
| mean(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.mean`.
|
| min(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.min`.
|
| newbyteorder(...)
| newbyteorder(new_order='S', /)
|
| Return a new `dtype` with a different byte order.
|
| Changes are also made in all fields and sub-arrays of the data type.
|
| The `new_order` code can be any from the following:
|
| * 'S' - swap dtype from current to opposite endian
| * {'<', 'little'} - little endian
| * {'>', 'big'} - big endian
| * {'=', 'native'} - 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.
|
|
| Returns
| -------
| new_dtype : dtype
| New `dtype` object with the given change to the byte order.
|
| nonzero(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.nonzero`.
|
| prod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.prod`.
|
| ptp(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ptp`.
|
| put(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.put`.
|
| ravel(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ravel`.
|
| repeat(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.repeat`.
|
| reshape(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.reshape`.
|
| resize(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.resize`.
|
| round(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.round`.
|
| searchsorted(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.searchsorted`.
|
| setfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setfield`.
|
| setflags(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setflags`.
|
| sort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sort`.
|
| squeeze(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.squeeze`.
|
| std(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.std`.
|
| sum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sum`.
|
| swapaxes(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.swapaxes`.
|
| take(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.take`.
|
| tobytes(...)
|
| tofile(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tofile`.
|
| tolist(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tolist`.
|
| tostring(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tostring`.
|
| trace(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.trace`.
|
| transpose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.transpose`.
|
| var(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.var`.
|
| view(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.view`.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from generic:
|
| T
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.T`.
|
| __array_interface__
| Array protocol: Python side
|
| __array_priority__
| Array priority.
|
| __array_struct__
| Array protocol: struct
|
| base
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.base`.
|
| data
| Pointer to start of data.
|
| dtype
| Get array data-descriptor.
|
| flags
| The integer value of flags.
|
| flat
| A 1-D view of the scalar.
|
| imag
| The imaginary part of the scalar.
|
| itemsize
| The length of one element in bytes.
|
| nbytes
| The length of the scalar in bytes.
|
| ndim
| The number of array dimensions.
|
| real
| The real part of the scalar.
|
| shape
| Tuple of array dimensions.
|
| size
| The number of elements in the gentype.
|
| strides
| Tuple of bytes steps in each dimension.

clongfloat = class clongdouble(complexfloating)

| Complex number type composed of two extended-precision floating-point
| numbers.
|
| :Character code: ``'G'``
| :Alias: `numpy.clongfloat`
| :Alias: `numpy.longcomplex`
|
| Method resolution order:
| clongdouble
| complexfloating
| inexact
| number
| generic
| builtins.object
|
| Methods defined here:
|
| __abs__(self, /)
| abs(self)
|
| __add__(self, value, /)
| Return self+value.
|
| __bool__(self, /)
| True if self else False
|
| __complex__(...)
|
| __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.
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| __class_getitem__(...) from builtins.type
| __class_getitem__(item, /)
|
| Return a parametrized wrapper around the `~numpy.number` type.
|
| .. versionadded:: 1.22
|
| Returns
| -------
| alias : types.GenericAlias
| A parametrized `~numpy.number` type.
|
| Examples
| --------
| >>> from typing import Any
| >>> import numpy as np
|
| >>> np.signedinteger[Any]
| numpy.signedinteger[typing.Any]
|
| See Also
| --------
| :pep:`585` : Type hinting generics in standard collections.
|
| ----------------------------------------------------------------------
| 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__(...)
|
| __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(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.all`.
|
| any(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.any`.
|
| argmax(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmax`.
|
| argmin(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmin`.
|
| argsort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argsort`.
|
| astype(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.astype`.
|
| byteswap(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.byteswap`.
|
| choose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.choose`.
|
| clip(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.clip`.
|
| compress(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.compress`.
|
| conj(...)
|
| conjugate(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.conjugate`.
|
| copy(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.copy`.
|
| cumprod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumprod`.
|
| cumsum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumsum`.
|
| diagonal(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.diagonal`.
|
| dump(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dump`.
|
| dumps(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dumps`.
|
| fill(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.fill`.
|
| flatten(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.flatten`.
|
| getfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.getfield`.
|
| item(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.item`.
|
| itemset(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.itemset`.
|
| max(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.max`.
|
| mean(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.mean`.
|
| min(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.min`.
|
| newbyteorder(...)
| newbyteorder(new_order='S', /)
|
| Return a new `dtype` with a different byte order.
|
| Changes are also made in all fields and sub-arrays of the data type.
|
| The `new_order` code can be any from the following:
|
| * 'S' - swap dtype from current to opposite endian
| * {'<', 'little'} - little endian
| * {'>', 'big'} - big endian
| * {'=', 'native'} - 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.
|
|
| Returns
| -------
| new_dtype : dtype
| New `dtype` object with the given change to the byte order.
|
| nonzero(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.nonzero`.
|
| prod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.prod`.
|
| ptp(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ptp`.
|
| put(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.put`.
|
| ravel(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ravel`.
|
| repeat(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.repeat`.
|
| reshape(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.reshape`.
|
| resize(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.resize`.
|
| round(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.round`.
|
| searchsorted(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.searchsorted`.
|
| setfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setfield`.
|
| setflags(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setflags`.
|
| sort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sort`.
|
| squeeze(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.squeeze`.
|
| std(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.std`.
|
| sum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sum`.
|
| swapaxes(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.swapaxes`.
|
| take(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.take`.
|
| tobytes(...)
|
| tofile(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tofile`.
|
| tolist(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tolist`.
|
| tostring(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tostring`.
|
| trace(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.trace`.
|
| transpose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.transpose`.
|
| var(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.var`.
|
| view(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.view`.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from generic:
|
| T
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.T`.
|
| __array_interface__
| Array protocol: Python side
|
 | __array_priority__
| Array priority.
|
| __array_struct__
| Array protocol: struct
|
| base
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.base`.
|
| data
| Pointer to start of data.
|
| dtype
| Get array data-descriptor.
|
| flags
| The integer value of flags.
|
| flat
| A 1-D view of the scalar.
|
| imag
| The imaginary part of the scalar.
|
| itemsize
| The length of one element in bytes.
|
| nbytes
| The length of the scalar in bytes.
|
| ndim
| The number of array dimensions.
|
| real
| The real part of the scalar.
|
| shape
| Tuple of array dimensions.
|
| size
| The 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: `numpy.cdouble`
| :Alias: `numpy.cfloat`
| :Alias: `numpy.complex_`
| :Alias on this platform (win32 AMD64): `numpy.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, /)
| True if self else False
|
| __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.
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| __class_getitem__(...) from builtins.type
| __class_getitem__(item, /)
|
| Return a parametrized wrapper around the `~numpy.number` type.
|
| .. versionadded:: 1.22
|
| Returns
| -------
| alias : types.GenericAlias
| A parametrized `~numpy.number` type.
|
| Examples
| --------
| >>> from typing import Any
| >>> import numpy as np
|
| >>> np.signedinteger[Any]
| numpy.signedinteger[typing.Any]
|
| See Also
| --------
| :pep:`585` : Type hinting generics in standard collections.
|
| ----------------------------------------------------------------------
| 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__(...)
|
| __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(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.all`.
|
| any(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.any`.
|
| argmax(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmax`.
|
| argmin(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmin`.
|
| argsort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argsort`.
|
| astype(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.astype`.
|
| byteswap(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.byteswap`.
|
| choose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.choose`.
|
| clip(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.clip`.
|
| compress(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.compress`.
|
| conj(...)
|
| conjugate(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.conjugate`.
|
| copy(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.copy`.
|
| cumprod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumprod`.
|
| cumsum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumsum`.
|
| diagonal(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.diagonal`.
|
| dump(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dump`.
|
| dumps(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dumps`.
|
| fill(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.fill`.
|
| flatten(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.flatten`.
|
| getfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.getfield`.
|
| item(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.item`.
|
| itemset(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.itemset`.
|
| max(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.max`.
|
| mean(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.mean`.
|
| min(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.min`.
|
| newbyteorder(...)
| newbyteorder(new_order='S', /)
|
| Return a new `dtype` with a different byte order.
|
| Changes are also made in all fields and sub-arrays of the data type.
|
| The `new_order` code can be any from the following:
|
| * 'S' - swap dtype from current to opposite endian
| * {'<', 'little'} - little endian
| * {'>', 'big'} - big endian
| * {'=', 'native'} - 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.
|
|
| Returns
| -------
| new_dtype : dtype
| New `dtype` object with the given change to the byte order.
|
| nonzero(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.nonzero`.
|
| prod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.prod`.
|
| ptp(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ptp`.
|
| put(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.put`.
|
| ravel(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ravel`.
|
| repeat(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.repeat`.
|
| reshape(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.reshape`.
|
| resize(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.resize`.
|
| round(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.round`.
|
| searchsorted(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.searchsorted`.
|
| setfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setfield`.
|
| setflags(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setflags`.
|
| sort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sort`.
|
| squeeze(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.squeeze`.
|
| std(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.std`.
|
| sum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sum`.
|
| swapaxes(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.swapaxes`.
|
| take(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.take`.
|
| tobytes(...)
|
| tofile(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tofile`.
|
| tolist(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tolist`.
|
| tostring(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tostring`.
|
| trace(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.trace`.
|
| transpose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.transpose`.
|
| var(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.var`.
|
| view(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.view`.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from generic:
|
| T
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.T`.
|
| __array_interface__
| Array protocol: Python side
|
| __array_priority__
| Array priority.
|
| __array_struct__
| Array protocol: struct
|
| base
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.base`.
|
| data
| Pointer to start of data.
|
| dtype
| Get array data-descriptor.
|
| flags
| The integer value of flags.
|
| flat
| A 1-D view of the scalar.
|
| imag
| The imaginary part of the scalar.
|
| itemsize
| The length of one element in bytes.
|
| nbytes
| The length of the scalar in bytes.
|
| ndim
| The number of array dimensions.
|
 | real
| The real part of the scalar.
|
| shape
| Tuple of array dimensions.
|
| size
| The number of elements in the gentype.
|
| strides
| Tuple of bytes steps in each dimension.
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.complex:
|
| __complex__(self, /)
| Convert this value to exact type complex.
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __getnewargs__(self, /)

class complex64(complexfloating)
| Complex number type composed of two single-precision floating-point
| numbers.
|
| :Character code: ``'F'``
| :Canonical name: `numpy.csingle`
| :Alias: `numpy.singlecomplex`
| :Alias on this platform (win32 AMD64): `numpy.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, /)
| True if self else False
|
| __complex__(...)
|
| __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.
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| __class_getitem__(...) from builtins.type
| __class_getitem__(item, /)
|
| Return a parametrized wrapper around the `~numpy.number` type.
|
| .. versionadded:: 1.22
|
| Returns
| -------
| alias : types.GenericAlias
| A parametrized `~numpy.number` type.
|
| Examples
| --------
| >>> from typing import Any
| >>> import numpy as np
|
| >>> np.signedinteger[Any]
| numpy.signedinteger[typing.Any]
|
| See Also
| --------
| :pep:`585` : Type hinting generics in standard collections.
|
| ----------------------------------------------------------------------
| 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__(...)
|
| __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(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.all`.
|
| any(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.any`.
|
| argmax(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmax`.
|
| argmin(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmin`.
|
| argsort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argsort`.
|
| astype(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.astype`.
|
| byteswap(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.byteswap`.
|
| choose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.choose`.
|
| clip(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.clip`.
|
| compress(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.compress`.
|
| conj(...)
|
| conjugate(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.conjugate`.
|
| copy(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.copy`.
|
| cumprod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumprod`.
|
| cumsum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumsum`.
|
| diagonal(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.diagonal`.
|
| dump(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dump`.
|
| dumps(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dumps`.
|
| fill(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.fill`.
|
| flatten(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.flatten`.
|
| getfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.getfield`.
|
| item(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.item`.
|
| itemset(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.itemset`.
|
| max(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.max`.
|
| mean(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.mean`.
|
| min(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.min`.
|
| newbyteorder(...)
| newbyteorder(new_order='S', /)
|
| Return a new `dtype` with a different byte order.
|
| Changes are also made in all fields and sub-arrays of the data type.
|
| The `new_order` code can be any from the following:
|
| * 'S' - swap dtype from current to opposite endian
| * {'<', 'little'} - little endian
| * {'>', 'big'} - big endian
| * {'=', 'native'} - 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.
|
|
| Returns
| -------
| new_dtype : dtype
| New `dtype` object with the given change to the byte order.
|
| nonzero(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.nonzero`.
|
| prod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.prod`.
|
| ptp(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ptp`.
|
| put(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.put`.
|
| ravel(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ravel`.
|
| repeat(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.repeat`.
|
| reshape(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.reshape`.
|
| resize(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.resize`.
|
| round(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.round`.
|
| searchsorted(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.searchsorted`.
|
| setfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setfield`.
|
| setflags(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setflags`.
|
| sort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sort`.
|
| squeeze(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.squeeze`.
|
| std(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.std`.
|
| sum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sum`.
|
| swapaxes(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.swapaxes`.
|
| take(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.take`.
|
| tobytes(...)
|
| tofile(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tofile`.
|
| tolist(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tolist`.
|
| tostring(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tostring`.
|
| trace(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.trace`.
|
| transpose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.transpose`.
|
| var(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.var`.
|
| view(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.view`.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from generic:
|
| T
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.T`.
|
| __array_interface__
| Array protocol: Python side
|
| __array_priority__
| Array priority.
 |
| __array_struct__
| Array protocol: struct
|
| base
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.base`.
|
| data
| Pointer to start of data.
|
| dtype
| Get array data-descriptor.
|
| flags
| The integer value of flags.
|
| flat
| A 1-D view of the scalar.
|
| imag
| The imaginary part of the scalar.
|
| itemsize
| The length of one element in bytes.
|
| nbytes
| The length of the scalar in bytes.
|
| ndim
| The number of array dimensions.
|
| real
| The real part of the scalar.
|
| shape
| Tuple of array dimensions.
|
| size
| The 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: `numpy.cdouble`
| :Alias: `numpy.cfloat`
| :Alias: `numpy.complex_`
| :Alias on this platform (win32 AMD64): `numpy.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, /)
| True if self else False
|
| __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.
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| __class_getitem__(...) from builtins.type
| __class_getitem__(item, /)
|
| Return a parametrized wrapper around the `~numpy.number` type.
|
| .. versionadded:: 1.22
|
| Returns
| -------
| alias : types.GenericAlias
| A parametrized `~numpy.number` type.
|
| Examples
| --------
| >>> from typing import Any
| >>> import numpy as np
|
| >>> np.signedinteger[Any]
| numpy.signedinteger[typing.Any]
|
| See Also
| --------
| :pep:`585` : Type hinting generics in standard collections.
|
| ----------------------------------------------------------------------
| 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__(...)
|
| __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(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.all`.
|
| any(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.any`.
|
| argmax(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmax`.
|
| argmin(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmin`.
|
| argsort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argsort`.
|
| astype(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.astype`.
|
| byteswap(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.byteswap`.
|
| choose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.choose`.
|
| clip(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.clip`.
|
| compress(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.compress`.
|
| conj(...)
|
| conjugate(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.conjugate`.
|
| copy(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.copy`.
|
| cumprod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumprod`.
|
| cumsum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumsum`.
|
| diagonal(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.diagonal`.
|
| dump(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dump`.
|
| dumps(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dumps`.
|
| fill(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.fill`.
|
| flatten(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.flatten`.
|
| getfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.getfield`.
|
| item(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.item`.
|
| itemset(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.itemset`.
|
| max(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.max`.
|
| mean(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.mean`.
|
| min(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.min`.
|
| newbyteorder(...)
| newbyteorder(new_order='S', /)
|
| Return a new `dtype` with a different byte order.
|
| Changes are also made in all fields and sub-arrays of the data type.
|
| The `new_order` code can be any from the following:
|
| * 'S' - swap dtype from current to opposite endian
| * {'<', 'little'} - little endian
| * {'>', 'big'} - big endian
| * {'=', 'native'} - 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.
|
|
| Returns
| -------
| new_dtype : dtype
| New `dtype` object with the given change to the byte order.
|
| nonzero(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.nonzero`.
|
| prod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.prod`.
|
| ptp(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ptp`.
|
| put(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.put`.
|
| ravel(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ravel`.
|
| repeat(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.repeat`.
|
| reshape(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.reshape`.
|
| resize(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.resize`.
|
| round(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.round`.
|
| searchsorted(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.searchsorted`.
|
| setfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setfield`.
|
| setflags(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setflags`.
|
| sort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sort`.
|
| squeeze(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.squeeze`.
|
| std(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.std`.
|
| sum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sum`.
|
| swapaxes(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.swapaxes`.
|
| take(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.take`.
|
| tobytes(...)
|
| tofile(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tofile`.
|
| tolist(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tolist`.
|
| tostring(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tostring`.
|
| trace(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.trace`.
|
| transpose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.transpose`.
|
| var(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.var`.
|
| view(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.view`.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from generic:
|
| T
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.T`.
|
| __array_interface__
| Array protocol: Python side
|
| __array_priority__
| Array priority.
|
| __array_struct__
| Array protocol: struct
|
| base
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.base`.
|
| data
| Pointer to start of data.
|
| dtype
| Get array data-descriptor.
|
| flags
| The integer value of flags.
|
| flat
| A 1-D view of the scalar.
|
| imag
| The imaginary part of the scalar.
|
| itemsize
| The length of one element in bytes.
|
| nbytes
| The length of the scalar in bytes.
|
| ndim
| The number of array dimensions.
|
| real
| The real part of the scalar.
|
| shape
| Tuple of array dimensions.
|
| size
| The number of elements in the gentype.
|
| strides
| Tuple of bytes steps in each dimension.
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.complex:
|
| __complex__(self, /)
| Convert this value to exact type complex.
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __getnewargs__(self, /)

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__(...)
|
| ----------------------------------------------------------------------
| Class methods inherited from number:
|
| __class_getitem__(...) from builtins.type
| __class_getitem__(item, /)
|
| Return a parametrized wrapper around the `~numpy.number` type.
|
| .. versionadded:: 1.22
|
| Returns
| -------
| alias : types.GenericAlias
| A parametrized `~numpy.number` type.
|
| Examples
| --------
| >>> from typing import Any
| >>> import numpy as np
|
| >>> np.signedinteger[Any]
| numpy.signedinteger[typing.Any]
|
| See Also
| --------
| :pep:`585` : Type hinting generics in standard collections.
|
| ----------------------------------------------------------------------
| 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, /)
| True if self else False
|
| __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(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.all`.
|
| any(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.any`.
|
| argmax(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmax`.
|
| argmin(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmin`.
|
| argsort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argsort`.
|
| astype(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.astype`.
|
| byteswap(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.byteswap`.
|
| choose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.choose`.
|
| clip(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.clip`.
|
| compress(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.compress`.
|
| conj(...)
|
| conjugate(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.conjugate`.
|
| copy(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.copy`.
|
| cumprod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumprod`.
|
| cumsum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumsum`.
|
| diagonal(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.diagonal`.
|
| dump(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dump`.
|
| dumps(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dumps`.
|
| fill(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.fill`.
|
| flatten(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.flatten`.
|
| getfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.getfield`.
|
| item(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.item`.
|
| itemset(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.itemset`.
|
| max(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.max`.
|
| mean(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.mean`.
|
| min(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.min`.
|
| newbyteorder(...)
| newbyteorder(new_order='S', /)
|
| Return a new `dtype` with a different byte order.
|
| Changes are also made in all fields and sub-arrays of the data type.
|
| The `new_order` code can be any from the following:
|
| * 'S' - swap dtype from current to opposite endian
| * {'<', 'little'} - little endian
| * {'>', 'big'} - big endian
| * {'=', 'native'} - 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.
|
|
| Returns
| -------
| new_dtype : dtype
| New `dtype` object with the given change to the byte order.
|
| nonzero(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.nonzero`.
|
| prod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.prod`.
|
| ptp(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ptp`.
|
| put(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.put`.
|
| ravel(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ravel`.
|
| repeat(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.repeat`.
|
| reshape(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.reshape`.
|
| resize(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.resize`.
|
| round(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.round`.
|
| searchsorted(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.searchsorted`.
|
| setfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setfield`.
|
| setflags(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setflags`.
|
| sort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sort`.
|
| squeeze(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.squeeze`.
|
| std(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.std`.
|
| sum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sum`.
|
| swapaxes(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.swapaxes`.
|
| take(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.take`.
|
| tobytes(...)
|
| tofile(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tofile`.
|
| tolist(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tolist`.
|
| tostring(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tostring`.
|
| trace(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.trace`.
|
| transpose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.transpose`.
|
| var(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.var`.
|
| view(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.view`.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from generic:
|
| T
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.T`.
|
| __array_interface__
| Array protocol: Python side
|
| __array_priority__
| Array priority.
|
| __array_struct__
| Array protocol: struct
|
| base
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.base`.
|
| data
| Pointer to start of data.
|
| dtype
| Get array data-descriptor.
|
| flags
| The integer value of flags.
|
| flat
| A 1-D view of the scalar.
|
| imag
| The imaginary part of the scalar.
|
| itemsize
| The length of one element in bytes.
|
| nbytes
| The length of the scalar in bytes.
 |
| ndim
| The number of array dimensions.
|
| real
| The real part of the scalar.
|
| shape
| Tuple of array dimensions.
|
| size
| The 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: `numpy.csingle`
| :Alias: `numpy.singlecomplex`
| :Alias on this platform (win32 AMD64): `numpy.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, /)
| True if self else False
|
| __complex__(...)
|
| __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.
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| __class_getitem__(...) from builtins.type
| __class_getitem__(item, /)
|
| Return a parametrized wrapper around the `~numpy.number` type.
|
| .. versionadded:: 1.22
|
| Returns
| -------
| alias : types.GenericAlias
| A parametrized `~numpy.number` type.
|
| Examples
| --------
| >>> from typing import Any
| >>> import numpy as np
|
| >>> np.signedinteger[Any]
| numpy.signedinteger[typing.Any]
|
| See Also
| --------
| :pep:`585` : Type hinting generics in standard collections.
|
| ----------------------------------------------------------------------
| 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__(...)
|
| __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(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.all`.
|
| any(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.any`.
|
| argmax(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmax`.
|
| argmin(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmin`.
|
| argsort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argsort`.
|
| astype(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.astype`.
|
| byteswap(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.byteswap`.
|
| choose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.choose`.
|
| clip(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.clip`.
|
| compress(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.compress`.
|
| conj(...)
|
| conjugate(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.conjugate`.
|
| copy(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.copy`.
|
| cumprod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumprod`.
|
| cumsum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumsum`.
|
| diagonal(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.diagonal`.
|
| dump(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dump`.
|
| dumps(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dumps`.
|
| fill(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.fill`.
|
| flatten(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.flatten`.
|
| getfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.getfield`.
|
| item(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.item`.
|
| itemset(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.itemset`.
|
| max(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.max`.
|
| mean(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.mean`.
|
| min(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.min`.
|
| newbyteorder(...)
| newbyteorder(new_order='S', /)
|
| Return a new `dtype` with a different byte order.
|
| Changes are also made in all fields and sub-arrays of the data type.
|
| The `new_order` code can be any from the following:
|
| * 'S' - swap dtype from current to opposite endian
| * {'<', 'little'} - little endian
| * {'>', 'big'} - big endian
| * {'=', 'native'} - 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.
|
|
| Returns
| -------
| new_dtype : dtype
| New `dtype` object with the given change to the byte order.
|
| nonzero(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.nonzero`.
|
| prod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.prod`.
|
| ptp(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ptp`.
|
| put(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.put`.
|
| ravel(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ravel`.
|
| repeat(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.repeat`.
|
| reshape(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.reshape`.
|
| resize(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.resize`.
|
| round(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.round`.
|
| searchsorted(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.searchsorted`.
|
| setfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setfield`.
|
| setflags(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setflags`.
|
| sort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sort`.
|
| squeeze(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.squeeze`.
|
| std(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.std`.
|
| sum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sum`.
|
| swapaxes(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.swapaxes`.
|
| take(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.take`.
|
| tobytes(...)
|
| tofile(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tofile`.
|
| tolist(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tolist`.
|
| tostring(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tostring`.
|
| trace(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.trace`.
|
| transpose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.transpose`.
|
| var(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.var`.
|
| view(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.view`.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from generic:
|
| T
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.T`.
|
| __array_interface__
| Array protocol: Python side
|
| __array_priority__
| Array priority.
|
| __array_struct__
| Array protocol: struct
|
| base
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.base`.
|
| data
| Pointer to start of data.
|
| dtype
| Get array data-descriptor.
|
| flags
| The integer value of flags.
|
| flat
| A 1-D view of the scalar.
|
| imag
| The imaginary part of the scalar.
|
| itemsize
| The length of one element in bytes.
|
| nbytes
| The length of the scalar in bytes.
|
| ndim
| The number of array dimensions.
|
| real
| The real part of the scalar.
|
| shape
| Tuple of array dimensions.
|
| size
| The number of elements in the gentype.
|
| strides
| Tuple of bytes steps in each dimension.

class datetime64(generic)
| If created from a 64-bit integer, it represents an offset from
| ``1970-01-01T00:00:00``.
| If created from string, the string can be in ISO 8601 date
| or datetime format.
|
| >>> np.datetime64(10, 'Y')
| numpy.datetime64('1980')
| >>> np.datetime64('1980', 'Y')
| numpy.datetime64('1980')
| >>> np.datetime64(10, 'D')
| numpy.datetime64('1970-01-11')
|
| See :ref:`arrays.datetime` for more information.
|
| :Character code: ``'M'``
|
| 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, /)
| True if self else False
|
| __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(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.all`.
|
| any(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.any`.
|
| argmax(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmax`.
|
| argmin(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmin`.
|
| argsort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argsort`.
|
| astype(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.astype`.
|
| byteswap(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.byteswap`.
|
| choose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.choose`.
|
| clip(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.clip`.
|
| compress(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.compress`.
|
| conj(...)
|
| conjugate(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.conjugate`.
|
| copy(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.copy`.
|
| cumprod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumprod`.
|
| cumsum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumsum`.
|
| diagonal(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.diagonal`.
|
| dump(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dump`.
|
| dumps(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dumps`.
|
| fill(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.fill`.
|
| flatten(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.flatten`.
|
| getfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.getfield`.
|
| item(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.item`.
|
| itemset(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.itemset`.
|
| max(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.max`.
|
| mean(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.mean`.
|
| min(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.min`.
|
| newbyteorder(...)
| newbyteorder(new_order='S', /)
|
| Return a new `dtype` with a different byte order.
|
| Changes are also made in all fields and sub-arrays of the data type.
|
| The `new_order` code can be any from the following:
|
| * 'S' - swap dtype from current to opposite endian
| * {'<', 'little'} - little endian
| * {'>', 'big'} - big endian
| * {'=', 'native'} - 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.
|
|
| Returns
| -------
| new_dtype : dtype
| New `dtype` object with the given change to the byte order.
|
| nonzero(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.nonzero`.
|
| prod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.prod`.
|
| ptp(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ptp`.
|
| put(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.put`.
|
| ravel(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ravel`.
|
| repeat(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.repeat`.
|
| reshape(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.reshape`.
|
| resize(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.resize`.
|
| round(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.round`.
|
| searchsorted(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.searchsorted`.
|
| setfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setfield`.
|
| setflags(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setflags`.
|
| sort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sort`.
|
| squeeze(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.squeeze`.
|
| std(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.std`.
|
| sum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sum`.
|
| swapaxes(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.swapaxes`.
|
| take(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.take`.
|
| tobytes(...)
|
| tofile(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tofile`.
|
| tolist(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tolist`.
|
| tostring(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tostring`.
|
| trace(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.trace`.
|
| transpose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.transpose`.
|
| var(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.var`.
|
| view(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.view`.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from generic:
|
| T
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.T`.
|
| __array_interface__
| Array protocol: Python side
|
| __array_priority__
| Array priority.
|
| __array_struct__
| Array protocol: struct
|
| base
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.base`.
|
| data
 | Pointer to start of data.
|
| dtype
| Get array data-descriptor.
|
| flags
| The integer value of flags.
|
| flat
| A 1-D view of the scalar.
|
| imag
| The imaginary part of the scalar.
|
| itemsize
| The length of one element in bytes.
|
| nbytes
| The length of the scalar in bytes.
|
| ndim
| The number of array dimensions.
|
| real
| The real part of the scalar.
|
| shape
| Tuple of array dimensions.
|
| size
| The 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: `numpy.double`
| :Alias: `numpy.float_`
| :Alias on this platform (win32 AMD64): `numpy.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, /)
| True if self else False
|
| __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)
|
| is_integer(...)
| double.is_integer() -> bool
|
| Return ``True`` if the floating point number is finite with integral
| value, and ``False`` otherwise.
|
| .. versionadded:: 1.22
|
| Examples
| --------
| >>> np.double(-2.0).is_integer()
| True
| >>> np.double(3.2).is_integer()
| False
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| __class_getitem__(...) from builtins.type
| __class_getitem__(item, /)
|
| Return a parametrized wrapper around the `~numpy.number` type.
|
| .. versionadded:: 1.22
|
| Returns
| -------
| alias : types.GenericAlias
| A parametrized `~numpy.number` type.
|
| Examples
| --------
| >>> from typing import Any
| >>> import numpy as np
|
| >>> np.signedinteger[Any]
| numpy.signedinteger[typing.Any]
|
| See Also
| --------
| :pep:`585` : Type hinting generics in standard collections.
|
| ----------------------------------------------------------------------
| 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(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.all`.
|
| any(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.any`.
|
| argmax(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmax`.
|
| argmin(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmin`.
|
| argsort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argsort`.
|
| astype(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.astype`.
|
| byteswap(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.byteswap`.
|
| choose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.choose`.
|
| clip(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.clip`.
|
| compress(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.compress`.
|
| conj(...)
|
| conjugate(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.conjugate`.
|
| copy(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.copy`.
|
| cumprod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumprod`.
|
| cumsum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumsum`.
|
| diagonal(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.diagonal`.
|
| dump(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dump`.
|
| dumps(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dumps`.
|
| fill(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.fill`.
|
| flatten(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.flatten`.
|
| getfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.getfield`.
|
| item(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.item`.
|
| itemset(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.itemset`.
|
| max(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.max`.
|
| mean(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.mean`.
|
| min(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.min`.
|
| newbyteorder(...)
| newbyteorder(new_order='S', /)
|
| Return a new `dtype` with a different byte order.
|
| Changes are also made in all fields and sub-arrays of the data type.
|
| The `new_order` code can be any from the following:
|
| * 'S' - swap dtype from current to opposite endian
| * {'<', 'little'} - little endian
| * {'>', 'big'} - big endian
| * {'=', 'native'} - 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.
|
|
| Returns
| -------
| new_dtype : dtype
| New `dtype` object with the given change to the byte order.
|
| nonzero(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.nonzero`.
|
| prod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.prod`.
|
| ptp(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ptp`.
|
| put(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.put`.
|
| ravel(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ravel`.
|
| repeat(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.repeat`.
|
| reshape(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.reshape`.
|
| resize(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.resize`.
|
| round(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.round`.
|
| searchsorted(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.searchsorted`.
|
| setfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setfield`.
|
| setflags(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setflags`.
|
| sort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sort`.
|
| squeeze(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.squeeze`.
|
| std(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.std`.
|
| sum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sum`.
|
| swapaxes(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.swapaxes`.
|
| take(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.take`.
|
| tobytes(...)
|
| tofile(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tofile`.
|
| tolist(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tolist`.
|
| tostring(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tostring`.
|
| trace(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.trace`.
|
| transpose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.transpose`.
|
| var(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.var`.
|
| view(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.view`.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from generic:
|
| T
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.T`.
|
| __array_interface__
| Array protocol: Python side
|
| __array_priority__
| Array priority.
|
| __array_struct__
| Array protocol: struct
|
| base
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.base`.
|
| data
| Pointer to start of data.
|
| dtype
| Get array data-descriptor.
|
| flags
| The integer value of flags.
|
| flat
| A 1-D view of the scalar.
|
| imag
| The imaginary part of the scalar.
|
| itemsize
| The length of one element in bytes.
|
| nbytes
| The length of the scalar in bytes.
|
| ndim
| The number of array dimensions.
|
| real
| The real part of the scalar.
|
| shape
| Tuple of array dimensions.
|
| size
| The number of elements in the gentype.
|
| strides
| Tuple of bytes steps in each dimension.
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.float:
|
| __ceil__(self, /)
| Return the ceiling as an Integral.
|
| __floor__(self, /)
| Return the floor as an Integral.
|
| __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'
|
| ----------------------------------------------------------------------
| 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.
|
| 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(dtype, align=False, copy=False, [metadata])
|
| 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
| ----------
| dtype
| 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.
| metadata : dict, optional
| An optional dictionary with dtype metadata.
|
| 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, /)
| True if self else False
|
| __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
| * {'<', 'little'} - little endian
| * {'>', 'big'} - big endian
| * {'=', 'native'} - native order
| * {'|', 'I'} - ignore (no change to byte order)
|
| 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 = '<' if sys_is_le else '>'
| >>> swapped_code = '>' if sys_is_le else '<'
| >>> 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
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| __class_getitem__(...) from _DTypeMeta
| __class_getitem__(item, /)
|
| Return a parametrized wrapper around the `~numpy.dtype` type.
|
| .. versionadded:: 1.22
|
| Returns
| -------
| alias : types.GenericAlias
| A parametrized `~numpy.dtype` type.
|
| Examples
| --------
| >>> import numpy as np
|
| >>> np.dtype[np.int64]
| numpy.dtype[numpy.int64]
|
| See Also
| --------
| :pep:`585` : Type hinting generics in standard collections.
|
 | ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(*args, **kwargs) from _DTypeMeta
| 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 = '<' if sys_is_le else '>'
| >>> swapped_code = '>' if sys_is_le else '<'
| >>> 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
| Either ``None`` or a readonly dictionary of metadata (mappingproxy).
|
| The metadata field can be set using any dictionary at data-type
| creation. NumPy currently has no uniform approach to propagating
| metadata; although some array operations preserve it, there is no
| guarantee that others will.
|
| .. warning::
|
| Although used in certain projects, this feature was long
undocumented
| and is not well supported. Some aspects of metadata propagation
| are expected to change in the future.
|
| Examples
| --------
|
| >>> dt = np.dtype(float, metadata={"key": "value"})
| >>> dt.metadata["key"]
| 'value'
| >>> arr = np.array([1, 2, 3], dtype=dt)
| >>> arr.dtype.metadata
| mappingproxy({'key': 'value'})
|
| Adding arrays with identical datatypes currently preserves the
metadata:
|
| >>> (arr + arr).dtype.metadata
| mappingproxy({'key': 'value'})
|
| But if the arrays have different dtype metadata, the metadata may be
 | dropped:
|
| >>> dt2 = np.dtype(float, metadata={"key2": "value2"})
| >>> arr2 = np.array([3, 2, 1], dtype=dt2)
| >>> (arr + arr2).dtype.metadata is None
| True # The metadata field is cleared so None is returned
|
| 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
 class errstate(contextlib.ContextDecorator)
| errstate(*, call=<numpy.core._ufunc_config._unspecified object at
0x0000019BDA868FD0>, **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
| --------
| >>> 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:
|
| >>> np.geterr()
| {'divide': 'ignore', 'over': 'ignore', 'under': 'ignore', 'invalid':
'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
0x0000019BDA868FD0>, **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.
| dtype : dtype
| Returns the dtype for which `finfo` returns information. For complex
| input, the returned dtype is the associated ``float*`` dtype for its
| real and complex components.
| 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.
| 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
| An alias for `smallest_normal`, kept for backwards compatibility.
| smallest_normal : float
| The smallest positive floating point number with 1 as leading bit in
| the mantissa following IEEE-754 (see Notes).
| smallest_subnormal : float
| The smallest positive floating point number with 0 as leading bit in
| the mantissa following IEEE-754.
|
| Parameters
| ----------
| dtype : float, dtype, or instance
| Kind of floating point or complex floating point
| data-type about which to get information.
|
| See Also
| --------
| 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.
|
| Note that ``smallest_normal`` is not actually the smallest positive
| representable value in a NumPy floating point type. As in the IEEE-754
| standard [1]_, NumPy floating point types make use of subnormal numbers to
| fill the gap between 0 and ``smallest_normal``. However, subnormal numbers
| may have significantly reduced precision [2]_.
|
| This function can also be used for complex data types as well. If used,
| the output will be the same as the corresponding real float type
| (e.g. numpy.finfo(numpy.csingle) is the same as numpy.finfo(numpy.single)).
| However, the output is true for the real and imaginary components.
|
| References
| ----------
| .. [1] IEEE Standard for Floating-Point Arithmetic, IEEE Std 754-2008,
| pp.1-70, 2008, http://www.doi.org/10.1109/IEEESTD.2008.4610935
| .. [2] Wikipedia, "Denormal Numbers",
| https://en.wikipedia.org/wiki/Denormal_number
|
| Examples
| --------
| >>> np.finfo(np.float64).dtype
| dtype('float64')
| >>> np.finfo(np.complex64).dtype
| dtype('float32')
|
| 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.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| smallest_normal
| Return the value for the smallest normal.
|
| Returns
| -------
| smallest_normal : float
| Value for the smallest normal.
|
| Warns
| -----
| UserWarning
| If the calculated value for the smallest normal is requested for
| double-double.
|
| tiny
| Return the value for tiny, alias of smallest_normal.
|
| Returns
| -------
| tiny : float
| Value for the smallest normal, alias of smallest_normal.
|
| Warns
| -----
| UserWarning
| If the calculated value for the smallest normal is requested for
| double-double.
|
| ----------------------------------------------------------------------
| 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, /)
| True if self else False
|
| __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(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.all`.
|
| any(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.any`.
|
| argmax(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmax`.
|
| argmin(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmin`.
|
| argsort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argsort`.
|
| astype(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.astype`.
|
| byteswap(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.byteswap`.
|
| choose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.choose`.
|
| clip(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.clip`.
|
| compress(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.compress`.
|
| conj(...)
|
| conjugate(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.conjugate`.
|
| copy(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.copy`.
|
| cumprod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumprod`.
|
| cumsum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumsum`.
|
| diagonal(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.diagonal`.
|
| dump(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dump`.
|
| dumps(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dumps`.
|
| fill(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.fill`.
|
| flatten(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.flatten`.
|
| getfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.getfield`.
|
| item(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.item`.
|
| itemset(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.itemset`.
|
| max(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.max`.
|
| mean(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.mean`.
|
| min(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.min`.
|
| newbyteorder(...)
| newbyteorder(new_order='S', /)
|
| Return a new `dtype` with a different byte order.
|
| Changes are also made in all fields and sub-arrays of the data type.
|
| The `new_order` code can be any from the following:
|
| * 'S' - swap dtype from current to opposite endian
| * {'<', 'little'} - little endian
| * {'>', 'big'} - big endian
| * {'=', 'native'} - 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.
|
|
| Returns
| -------
| new_dtype : dtype
| New `dtype` object with the given change to the byte order.
|
| nonzero(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.nonzero`.
|
| prod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.prod`.
|
| ptp(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ptp`.
|
| put(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.put`.
|
| ravel(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ravel`.
|
| repeat(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.repeat`.
|
| reshape(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.reshape`.
|
| resize(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.resize`.
|
| round(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.round`.
|
| searchsorted(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.searchsorted`.
|
| setfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setfield`.
|
| setflags(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setflags`.
|
| sort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sort`.
|
| squeeze(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.squeeze`.
|
| std(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.std`.
|
| sum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sum`.
|
| swapaxes(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.swapaxes`.
|
| take(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.take`.
|
| tobytes(...)
|
| tofile(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tofile`.
|
| tolist(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tolist`.
|
| tostring(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tostring`.
|
| trace(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.trace`.
|
| transpose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.transpose`.
|
| var(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.var`.
|
| view(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.view`.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from generic:
|
| T
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.T`.
|
| __array_interface__
| Array protocol: Python side
|
| __array_priority__
| Array priority.
|
| __array_struct__
| Array protocol: struct
|
| base
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.base`.
|
| data
| Pointer to start of data.
|
| dtype
| Get array data-descriptor.
|
| flags
| The integer value of flags.
|
| flat
| A 1-D view of the scalar.
|
| imag
| The imaginary part of the scalar.
|
| itemsize
| The length of one element in bytes.
|
| nbytes
| The length of the scalar in bytes.
|
| ndim
| The number of array dimensions.
|
| real
| The real part of the scalar.
|
| shape
| Tuple of array dimensions.
|
| size
| The number of elements in the gentype.
|
| strides
| Tuple of bytes steps in each dimension.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from generic:
|
| __hash__ = None
 class float16(floating)
| Half-precision floating-point number type.
|
| :Character code: ``'e'``
| :Canonical name: `numpy.half`
| :Alias on this platform (win32 AMD64): `numpy.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, /)
| True if self else False
|
| __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)
|
| is_integer(...)
| half.is_integer() -> bool
|
| Return ``True`` if the floating point number is finite with integral
| value, and ``False`` otherwise.
|
| .. versionadded:: 1.22
|
| Examples
| --------
| >>> np.half(-2.0).is_integer()
| True
| >>> np.half(3.2).is_integer()
| False
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| __class_getitem__(...) from builtins.type
| __class_getitem__(item, /)
|
| Return a parametrized wrapper around the `~numpy.number` type.
|
| .. versionadded:: 1.22
|
| Returns
| -------
| alias : types.GenericAlias
| A parametrized `~numpy.number` type.
|
| Examples
| --------
| >>> from typing import Any
| >>> import numpy as np
|
| >>> np.signedinteger[Any]
| numpy.signedinteger[typing.Any]
|
| See Also
| --------
| :pep:`585` : Type hinting generics in standard collections.
|
| ----------------------------------------------------------------------
| 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(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.all`.
|
| any(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.any`.
|
| argmax(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmax`.
|
| argmin(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmin`.
|
| argsort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argsort`.
|
| astype(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.astype`.
|
| byteswap(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.byteswap`.
|
| choose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.choose`.
|
| clip(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.clip`.
|
| compress(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.compress`.
|
| conj(...)
|
| conjugate(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.conjugate`.
|
| copy(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.copy`.
|
| cumprod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumprod`.
|
| cumsum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumsum`.
|
| diagonal(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.diagonal`.
|
| dump(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dump`.
|
| dumps(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dumps`.
|
| fill(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.fill`.
|
| flatten(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.flatten`.
|
| getfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.getfield`.
|
| item(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.item`.
|
| itemset(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.itemset`.
|
| max(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.max`.
|
| mean(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.mean`.
|
| min(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.min`.
|
| newbyteorder(...)
| newbyteorder(new_order='S', /)
|
| Return a new `dtype` with a different byte order.
|
| Changes are also made in all fields and sub-arrays of the data type.
|
| The `new_order` code can be any from the following:
|
| * 'S' - swap dtype from current to opposite endian
| * {'<', 'little'} - little endian
| * {'>', 'big'} - big endian
| * {'=', 'native'} - 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.
|
|
| Returns
| -------
| new_dtype : dtype
| New `dtype` object with the given change to the byte order.
|
| nonzero(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.nonzero`.
|
| prod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.prod`.
|
| ptp(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ptp`.
|
| put(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.put`.
|
| ravel(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ravel`.
|
| repeat(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.repeat`.
|
| reshape(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.reshape`.
|
| resize(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.resize`.
|
| round(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.round`.
|
| searchsorted(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.searchsorted`.
|
| setfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setfield`.
|
| setflags(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setflags`.
|
| sort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sort`.
|
| squeeze(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.squeeze`.
|
| std(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.std`.
|
| sum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sum`.
|
| swapaxes(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.swapaxes`.
|
| take(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.take`.
|
| tobytes(...)
|
| tofile(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tofile`.
|
| tolist(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tolist`.
|
| tostring(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tostring`.
|
| trace(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.trace`.
|
| transpose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.transpose`.
|
| var(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.var`.
|
| view(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.view`.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from generic:
|
| T
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.T`.
|
| __array_interface__
| Array protocol: Python side
|
 | __array_priority__
| Array priority.
|
| __array_struct__
| Array protocol: struct
|
| base
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.base`.
|
| data
| Pointer to start of data.
|
| dtype
| Get array data-descriptor.
|
| flags
| The integer value of flags.
|
| flat
| A 1-D view of the scalar.
|
| imag
| The imaginary part of the scalar.
|
| itemsize
| The length of one element in bytes.
|
| nbytes
| The length of the scalar in bytes.
|
| ndim
| The number of array dimensions.
|
| real
| The real part of the scalar.
|
| shape
| Tuple of array dimensions.
|
| size
| The 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: `numpy.single`
| :Alias on this platform (win32 AMD64): `numpy.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, /)
| True if self else False
|
| __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)
|
| is_integer(...)
| single.is_integer() -> bool
|
| Return ``True`` if the floating point number is finite with integral
| value, and ``False`` otherwise.
|
| .. versionadded:: 1.22
|
| Examples
| --------
| >>> np.single(-2.0).is_integer()
| True
| >>> np.single(3.2).is_integer()
| False
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| __class_getitem__(...) from builtins.type
| __class_getitem__(item, /)
|
| Return a parametrized wrapper around the `~numpy.number` type.
|
| .. versionadded:: 1.22
|
| Returns
| -------
| alias : types.GenericAlias
| A parametrized `~numpy.number` type.
|
| Examples
| --------
| >>> from typing import Any
| >>> import numpy as np
|
| >>> np.signedinteger[Any]
| numpy.signedinteger[typing.Any]
|
| See Also
| --------
| :pep:`585` : Type hinting generics in standard collections.
|
| ----------------------------------------------------------------------
| 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(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.all`.
|
| any(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.any`.
|
| argmax(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmax`.
|
| argmin(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmin`.
|
| argsort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argsort`.
|
| astype(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.astype`.
|
| byteswap(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.byteswap`.
|
| choose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.choose`.
|
| clip(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.clip`.
|
| compress(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.compress`.
|
| conj(...)
|
| conjugate(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.conjugate`.
|
| copy(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.copy`.
|
| cumprod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumprod`.
|
| cumsum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumsum`.
|
| diagonal(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.diagonal`.
|
| dump(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dump`.
|
| dumps(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dumps`.
|
| fill(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.fill`.
|
| flatten(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.flatten`.
|
| getfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.getfield`.
|
| item(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.item`.
|
| itemset(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.itemset`.
|
| max(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.max`.
|
| mean(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.mean`.
|
| min(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.min`.
|
| newbyteorder(...)
| newbyteorder(new_order='S', /)
|
| Return a new `dtype` with a different byte order.
|
| Changes are also made in all fields and sub-arrays of the data type.
|
| The `new_order` code can be any from the following:
|
| * 'S' - swap dtype from current to opposite endian
| * {'<', 'little'} - little endian
| * {'>', 'big'} - big endian
| * {'=', 'native'} - 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.
|
|
| Returns
| -------
| new_dtype : dtype
| New `dtype` object with the given change to the byte order.
|
| nonzero(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.nonzero`.
|
| prod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.prod`.
|
| ptp(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ptp`.
|
| put(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.put`.
|
| ravel(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ravel`.
|
| repeat(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.repeat`.
|
| reshape(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.reshape`.
|
| resize(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.resize`.
|
| round(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.round`.
|
| searchsorted(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.searchsorted`.
|
| setfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setfield`.
|
| setflags(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setflags`.
|
| sort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sort`.
|
| squeeze(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.squeeze`.
|
| std(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.std`.
|
| sum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sum`.
|
| swapaxes(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.swapaxes`.
|
| take(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.take`.
|
| tobytes(...)
|
| tofile(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tofile`.
|
| tolist(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tolist`.
|
| tostring(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tostring`.
|
| trace(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.trace`.
|
| transpose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.transpose`.
|
| var(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.var`.
|
| view(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.view`.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from generic:
|
| T
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.T`.
|
| __array_interface__
| Array protocol: Python side
|
| __array_priority__
| Array priority.
|
| __array_struct__
| Array protocol: struct
|
| base
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.base`.
|
| data
 | Pointer to start of data.
|
| dtype
| Get array data-descriptor.
|
| flags
| The integer value of flags.
|
| flat
| A 1-D view of the scalar.
|
| imag
| The imaginary part of the scalar.
|
| itemsize
| The length of one element in bytes.
|
| nbytes
| The length of the scalar in bytes.
|
| ndim
| The number of array dimensions.
|
| real
| The real part of the scalar.
|
| shape
| Tuple of array dimensions.
|
| size
| The 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: `numpy.double`
| :Alias: `numpy.float_`
| :Alias on this platform (win32 AMD64): `numpy.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, /)
| True if self else False
|
| __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)
|
| is_integer(...)
| double.is_integer() -> bool
|
| Return ``True`` if the floating point number is finite with integral
| value, and ``False`` otherwise.
|
| .. versionadded:: 1.22
|
| Examples
| --------
| >>> np.double(-2.0).is_integer()
| True
| >>> np.double(3.2).is_integer()
| False
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| __class_getitem__(...) from builtins.type
| __class_getitem__(item, /)
|
| Return a parametrized wrapper around the `~numpy.number` type.
|
| .. versionadded:: 1.22
|
| Returns
| -------
| alias : types.GenericAlias
| A parametrized `~numpy.number` type.
|
| Examples
| --------
| >>> from typing import Any
| >>> import numpy as np
|
| >>> np.signedinteger[Any]
| numpy.signedinteger[typing.Any]
|
| See Also
| --------
| :pep:`585` : Type hinting generics in standard collections.
|
| ----------------------------------------------------------------------
| 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(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.all`.
|
| any(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.any`.
|
| argmax(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmax`.
|
| argmin(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmin`.
|
| argsort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argsort`.
|
| astype(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.astype`.
|
| byteswap(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.byteswap`.
|
| choose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.choose`.
|
| clip(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.clip`.
|
| compress(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.compress`.
|
| conj(...)
|
| conjugate(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.conjugate`.
|
| copy(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.copy`.
|
| cumprod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumprod`.
|
| cumsum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumsum`.
|
| diagonal(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.diagonal`.
|
| dump(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dump`.
|
| dumps(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dumps`.
|
| fill(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.fill`.
|
| flatten(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.flatten`.
|
| getfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.getfield`.
|
| item(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.item`.
|
| itemset(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.itemset`.
|
| max(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.max`.
|
| mean(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.mean`.
|
| min(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.min`.
|
| newbyteorder(...)
| newbyteorder(new_order='S', /)
|
| Return a new `dtype` with a different byte order.
|
| Changes are also made in all fields and sub-arrays of the data type.
|
| The `new_order` code can be any from the following:
|
| * 'S' - swap dtype from current to opposite endian
| * {'<', 'little'} - little endian
| * {'>', 'big'} - big endian
| * {'=', 'native'} - 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.
|
|
| Returns
| -------
| new_dtype : dtype
| New `dtype` object with the given change to the byte order.
|
| nonzero(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.nonzero`.
|
| prod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.prod`.
|
| ptp(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ptp`.
|
| put(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.put`.
|
| ravel(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ravel`.
|
| repeat(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.repeat`.
|
| reshape(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.reshape`.
|
| resize(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.resize`.
|
| round(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.round`.
|
| searchsorted(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.searchsorted`.
|
| setfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setfield`.
|
| setflags(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setflags`.
|
| sort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sort`.
|
| squeeze(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.squeeze`.
|
| std(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.std`.
|
| sum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sum`.
|
| swapaxes(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.swapaxes`.
|
| take(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.take`.
|
| tobytes(...)
|
| tofile(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tofile`.
|
| tolist(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tolist`.
|
| tostring(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tostring`.
|
| trace(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.trace`.
|
| transpose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.transpose`.
|
| var(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.var`.
|
| view(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.view`.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from generic:
|
| T
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.T`.
|
| __array_interface__
| Array protocol: Python side
|
| __array_priority__
| Array priority.
|
| __array_struct__
| Array protocol: struct
|
| base
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.base`.
|
| data
| Pointer to start of data.
|
| dtype
| Get array data-descriptor.
|
| flags
| The integer value of flags.
|
| flat
| A 1-D view of the scalar.
|
| imag
| The imaginary part of the scalar.
|
| itemsize
| The length of one element in bytes.
|
| nbytes
| The length of the scalar in bytes.
|
| ndim
| The number of array dimensions.
|
| real
| The real part of the scalar.
|
| shape
| Tuple of array dimensions.
|
| size
| The number of elements in the gentype.
|
| strides
| Tuple of bytes steps in each dimension.
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.float:
|
| __ceil__(self, /)
| Return the ceiling as an Integral.
|
| __floor__(self, /)
| Return the floor as an Integral.
|
| __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'
|
| ----------------------------------------------------------------------
| 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.
|
| 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: `numpy.double`
| :Alias: `numpy.float_`
| :Alias on this platform (win32 AMD64): `numpy.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, /)
| True if self else False
|
| __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)
|
| is_integer(...)
| double.is_integer() -> bool
|
| Return ``True`` if the floating point number is finite with integral
| value, and ``False`` otherwise.
|
| .. versionadded:: 1.22
|
| Examples
| --------
| >>> np.double(-2.0).is_integer()
| True
| >>> np.double(3.2).is_integer()
| False
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| __class_getitem__(...) from builtins.type
| __class_getitem__(item, /)
|
| Return a parametrized wrapper around the `~numpy.number` type.
|
| .. versionadded:: 1.22
|
| Returns
| -------
| alias : types.GenericAlias
| A parametrized `~numpy.number` type.
|
| Examples
| --------
| >>> from typing import Any
| >>> import numpy as np
|
| >>> np.signedinteger[Any]
| numpy.signedinteger[typing.Any]
|
| See Also
| --------
| :pep:`585` : Type hinting generics in standard collections.
|
| ----------------------------------------------------------------------
| 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(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.all`.
|
| any(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.any`.
|
| argmax(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmax`.
|
| argmin(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmin`.
|
| argsort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argsort`.
|
| astype(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.astype`.
|
| byteswap(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.byteswap`.
|
| choose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.choose`.
|
| clip(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.clip`.
|
| compress(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.compress`.
|
| conj(...)
|
| conjugate(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.conjugate`.
|
| copy(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.copy`.
|
| cumprod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumprod`.
|
| cumsum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumsum`.
|
| diagonal(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.diagonal`.
|
| dump(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dump`.
|
| dumps(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dumps`.
|
| fill(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.fill`.
|
| flatten(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.flatten`.
|
| getfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.getfield`.
|
| item(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.item`.
|
| itemset(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.itemset`.
|
| max(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.max`.
|
| mean(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.mean`.
|
| min(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.min`.
|
| newbyteorder(...)
| newbyteorder(new_order='S', /)
|
| Return a new `dtype` with a different byte order.
|
| Changes are also made in all fields and sub-arrays of the data type.
|
| The `new_order` code can be any from the following:
|
| * 'S' - swap dtype from current to opposite endian
| * {'<', 'little'} - little endian
| * {'>', 'big'} - big endian
| * {'=', 'native'} - 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.
|
|
| Returns
| -------
| new_dtype : dtype
| New `dtype` object with the given change to the byte order.
|
| nonzero(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.nonzero`.
|
| prod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.prod`.
|
| ptp(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ptp`.
|
| put(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.put`.
|
| ravel(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ravel`.
|
| repeat(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.repeat`.
|
| reshape(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.reshape`.
|
| resize(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.resize`.
|
| round(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.round`.
|
| searchsorted(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.searchsorted`.
|
| setfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setfield`.
|
| setflags(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setflags`.
|
| sort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sort`.
|
| squeeze(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.squeeze`.
|
| std(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.std`.
|
| sum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sum`.
|
| swapaxes(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.swapaxes`.
|
| take(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.take`.
|
| tobytes(...)
|
| tofile(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tofile`.
|
| tolist(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tolist`.
|
| tostring(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tostring`.
|
| trace(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.trace`.
|
| transpose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.transpose`.
|
| var(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.var`.
|
| view(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.view`.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from generic:
|
| T
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.T`.
|
| __array_interface__
| Array protocol: Python side
|
| __array_priority__
| Array priority.
|
| __array_struct__
| Array protocol: struct
|
| base
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.base`.
|
| data
| Pointer to start of data.
|
| dtype
| Get array data-descriptor.
|
| flags
| The integer value of flags.
|
| flat
| A 1-D view of the scalar.
|
| imag
| The imaginary part of the scalar.
|
| itemsize
| The length of one element in bytes.
|
| nbytes
| The length of the scalar in bytes.
|
| ndim
| The number of array dimensions.
|
 | real
| The real part of the scalar.
|
| shape
| Tuple of array dimensions.
|
| size
| The number of elements in the gentype.
|
| strides
| Tuple of bytes steps in each dimension.
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.float:
|
| __ceil__(self, /)
| Return the ceiling as an Integral.
|
| __floor__(self, /)
| Return the floor as an Integral.
|
| __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'
|
| ----------------------------------------------------------------------
| 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.
|
| 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__(...)
|
| ----------------------------------------------------------------------
| Class methods inherited from number:
|
| __class_getitem__(...) from builtins.type
| __class_getitem__(item, /)
|
| Return a parametrized wrapper around the `~numpy.number` type.
|
| .. versionadded:: 1.22
|
| Returns
| -------
| alias : types.GenericAlias
| A parametrized `~numpy.number` type.
|
| Examples
| --------
| >>> from typing import Any
| >>> import numpy as np
|
| >>> np.signedinteger[Any]
| numpy.signedinteger[typing.Any]
|
| See Also
| --------
| :pep:`585` : Type hinting generics in standard collections.
|
| ----------------------------------------------------------------------
| 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, /)
| True if self else False
|
| __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(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.all`.
|
| any(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.any`.
|
| argmax(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmax`.
|
| argmin(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmin`.
|
| argsort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argsort`.
|
| astype(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.astype`.
|
| byteswap(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.byteswap`.
|
| choose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.choose`.
|
| clip(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.clip`.
|
| compress(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.compress`.
|
| conj(...)
|
| conjugate(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.conjugate`.
|
| copy(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.copy`.
|
| cumprod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumprod`.
|
| cumsum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumsum`.
|
| diagonal(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.diagonal`.
|
| dump(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dump`.
|
| dumps(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dumps`.
|
| fill(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.fill`.
|
| flatten(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.flatten`.
|
| getfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.getfield`.
|
| item(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.item`.
|
| itemset(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.itemset`.
|
| max(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.max`.
|
| mean(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.mean`.
|
| min(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.min`.
|
| newbyteorder(...)
| newbyteorder(new_order='S', /)
|
| Return a new `dtype` with a different byte order.
|
| Changes are also made in all fields and sub-arrays of the data type.
|
| The `new_order` code can be any from the following:
|
| * 'S' - swap dtype from current to opposite endian
| * {'<', 'little'} - little endian
| * {'>', 'big'} - big endian
| * {'=', 'native'} - 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.
|
|
| Returns
| -------
| new_dtype : dtype
| New `dtype` object with the given change to the byte order.
|
| nonzero(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.nonzero`.
|
| prod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.prod`.
|
| ptp(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ptp`.
|
| put(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.put`.
|
| ravel(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ravel`.
|
| repeat(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.repeat`.
|
| reshape(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.reshape`.
|
| resize(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.resize`.
|
| round(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.round`.
|
| searchsorted(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.searchsorted`.
|
| setfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setfield`.
|
| setflags(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setflags`.
|
| sort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sort`.
|
| squeeze(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.squeeze`.
|
| std(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.std`.
|
| sum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sum`.
|
| swapaxes(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.swapaxes`.
|
| take(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.take`.
|
| tobytes(...)
|
| tofile(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tofile`.
|
| tolist(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tolist`.
|
| tostring(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tostring`.
|
| trace(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.trace`.
|
| transpose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.transpose`.
|
| var(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.var`.
|
| view(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.view`.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from generic:
|
| T
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.T`.
|
| __array_interface__
| Array protocol: Python side
|
| __array_priority__
| Array priority.
|
| __array_struct__
| Array protocol: struct
|
| base
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.base`.
|
| data
| Pointer to start of data.
|
| dtype
| Get array data-descriptor.
|
| flags
| The integer value of flags.
|
| flat
| A 1-D view of the scalar.
|
| imag
| The imaginary part of the scalar.
|
| itemsize
| The length of one element in bytes.
|
| nbytes
| The length of the scalar in bytes.
|
| ndim
| The number of array dimensions.
|
| real
| The real part of the scalar.
|
| shape
| Tuple of array dimensions.
|
| size
| The 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, /)
| True if self else False
|
| __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(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.all`.
|
| any(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.any`.
|
| argmax(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmax`.
|
| argmin(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmin`.
|
| argsort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argsort`.
|
| astype(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.astype`.
|
| byteswap(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.byteswap`.
|
| choose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.choose`.
|
| clip(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.clip`.
|
| compress(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.compress`.
|
| conj(...)
|
| conjugate(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.conjugate`.
|
| copy(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.copy`.
|
| cumprod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumprod`.
|
| cumsum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumsum`.
|
| diagonal(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.diagonal`.
|
| dump(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dump`.
|
| dumps(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dumps`.
|
| fill(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.fill`.
|
| flatten(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.flatten`.
|
| getfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.getfield`.
|
| item(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.item`.
|
| itemset(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.itemset`.
|
| max(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.max`.
|
| mean(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.mean`.
|
| min(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.min`.
|
| newbyteorder(...)
| newbyteorder(new_order='S', /)
|
| Return a new `dtype` with a different byte order.
|
| Changes are also made in all fields and sub-arrays of the data type.
|
| The `new_order` code can be any from the following:
|
| * 'S' - swap dtype from current to opposite endian
| * {'<', 'little'} - little endian
| * {'>', 'big'} - big endian
| * {'=', 'native'} - 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.
|
|
| Returns
| -------
| new_dtype : dtype
| New `dtype` object with the given change to the byte order.
|
| nonzero(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.nonzero`.
|
| prod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.prod`.
|
| ptp(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ptp`.
|
| put(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.put`.
|
| ravel(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ravel`.
|
| repeat(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.repeat`.
|
| reshape(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.reshape`.
|
| resize(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.resize`.
|
| round(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.round`.
|
| searchsorted(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.searchsorted`.
|
| setfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setfield`.
|
| setflags(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setflags`.
|
| sort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sort`.
|
| squeeze(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.squeeze`.
|
| std(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.std`.
|
| sum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sum`.
|
| swapaxes(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.swapaxes`.
|
| take(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.take`.
|
| tobytes(...)
|
| tofile(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tofile`.
|
| tolist(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tolist`.
|
| tostring(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tostring`.
|
| trace(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.trace`.
|
| transpose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.transpose`.
|
| var(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.var`.
|
| view(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.view`.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| T
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.T`.
|
| __array_interface__
| Array protocol: Python side
|
| __array_priority__
| Array priority.
|
| __array_struct__
| Array protocol: struct
|
| base
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.base`.
|
 | data
| Pointer to start of data.
|
| dtype
| Get array data-descriptor.
|
| flags
| The integer value of flags.
|
| flat
| A 1-D view of the scalar.
|
| imag
| The imaginary part of the scalar.
|
| itemsize
| The length of one element in bytes.
|
| nbytes
| The length of the scalar in bytes.
|
| ndim
| The number of array dimensions.
|
| real
| The real part of the scalar.
|
| shape
| Tuple of array dimensions.
|
| size
| The 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: `numpy.half`
| :Alias on this platform (win32 AMD64): `numpy.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, /)
| True if self else False
|
| __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)
|
| is_integer(...)
| half.is_integer() -> bool
|
| Return ``True`` if the floating point number is finite with integral
| value, and ``False`` otherwise.
|
| .. versionadded:: 1.22
|
| Examples
| --------
| >>> np.half(-2.0).is_integer()
| True
| >>> np.half(3.2).is_integer()
| False
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| __class_getitem__(...) from builtins.type
| __class_getitem__(item, /)
|
| Return a parametrized wrapper around the `~numpy.number` type.
|
| .. versionadded:: 1.22
|
| Returns
| -------
| alias : types.GenericAlias
| A parametrized `~numpy.number` type.
|
| Examples
| --------
| >>> from typing import Any
| >>> import numpy as np
|
| >>> np.signedinteger[Any]
| numpy.signedinteger[typing.Any]
|
| See Also
| --------
| :pep:`585` : Type hinting generics in standard collections.
|
| ----------------------------------------------------------------------
| 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(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.all`.
|
| any(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.any`.
|
| argmax(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmax`.
|
| argmin(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmin`.
|
| argsort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argsort`.
|
| astype(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.astype`.
|
| byteswap(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.byteswap`.
|
| choose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.choose`.
|
| clip(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.clip`.
|
| compress(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.compress`.
|
| conj(...)
|
| conjugate(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.conjugate`.
|
| copy(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.copy`.
|
| cumprod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumprod`.
|
| cumsum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumsum`.
|
| diagonal(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.diagonal`.
|
| dump(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dump`.
|
| dumps(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dumps`.
|
| fill(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.fill`.
|
| flatten(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.flatten`.
|
| getfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.getfield`.
|
| item(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.item`.
|
| itemset(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.itemset`.
|
| max(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.max`.
|
| mean(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.mean`.
|
| min(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.min`.
|
| newbyteorder(...)
| newbyteorder(new_order='S', /)
|
| Return a new `dtype` with a different byte order.
|
| Changes are also made in all fields and sub-arrays of the data type.
|
| The `new_order` code can be any from the following:
|
| * 'S' - swap dtype from current to opposite endian
| * {'<', 'little'} - little endian
| * {'>', 'big'} - big endian
| * {'=', 'native'} - 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.
|
|
| Returns
| -------
| new_dtype : dtype
| New `dtype` object with the given change to the byte order.
|
| nonzero(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.nonzero`.
|
| prod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.prod`.
|
| ptp(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ptp`.
|
| put(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.put`.
|
| ravel(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ravel`.
|
| repeat(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.repeat`.
|
| reshape(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.reshape`.
|
| resize(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.resize`.
|
| round(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.round`.
|
| searchsorted(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.searchsorted`.
|
| setfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setfield`.
|
| setflags(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setflags`.
|
| sort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sort`.
|
| squeeze(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.squeeze`.
|
| std(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.std`.
|
| sum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sum`.
|
| swapaxes(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.swapaxes`.
|
| take(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.take`.
|
| tobytes(...)
|
| tofile(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tofile`.
|
| tolist(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tolist`.
|
| tostring(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tostring`.
|
| trace(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.trace`.
|
| transpose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.transpose`.
|
| var(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.var`.
|
| view(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.view`.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from generic:
|
| T
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.T`.
|
| __array_interface__
| Array protocol: Python side
|
| __array_priority__
| Array priority.
|
| __array_struct__
| Array protocol: struct
|
| base
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.base`.
|
| data
| Pointer to start of data.
|
| dtype
| Get array data-descriptor.
|
| flags
 | The integer value of flags.
|
| flat
| A 1-D view of the scalar.
|
| imag
| The imaginary part of the scalar.
|
| itemsize
| The length of one element in bytes.
|
| nbytes
| The length of the scalar in bytes.
|
| ndim
| The number of array dimensions.
|
| real
| The real part of the scalar.
|
| shape
| Tuple of array dimensions.
|
| size
| The 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.
| dtype : dtype
| Returns the dtype for which `iinfo` returns information.
| 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
|
| Class methods inherited from number:
|
| __class_getitem__(...) from builtins.type
| __class_getitem__(item, /)
|
| Return a parametrized wrapper around the `~numpy.number` type.
|
| .. versionadded:: 1.22
|
| Returns
| -------
| alias : types.GenericAlias
| A parametrized `~numpy.number` type.
|
| Examples
| --------
| >>> from typing import Any
| >>> import numpy as np
|
| >>> np.signedinteger[Any]
| numpy.signedinteger[typing.Any]
|
| See Also
| --------
| :pep:`585` : Type hinting generics in standard collections.
|
| ----------------------------------------------------------------------
| 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, /)
| True if self else False
|
| __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(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.all`.
|
| any(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.any`.
|
| argmax(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmax`.
|
| argmin(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmin`.
|
| argsort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argsort`.
|
| astype(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.astype`.
|
| byteswap(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.byteswap`.
|
| choose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.choose`.
|
| clip(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.clip`.
|
| compress(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.compress`.
|
| conj(...)
|
| conjugate(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.conjugate`.
|
| copy(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.copy`.
|
| cumprod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumprod`.
|
| cumsum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumsum`.
|
| diagonal(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.diagonal`.
|
| dump(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dump`.
|
| dumps(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dumps`.
|
| fill(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.fill`.
|
| flatten(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.flatten`.
|
| getfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.getfield`.
|
| item(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.item`.
|
| itemset(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.itemset`.
|
| max(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.max`.
|
| mean(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.mean`.
|
| min(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.min`.
|
| newbyteorder(...)
| newbyteorder(new_order='S', /)
|
| Return a new `dtype` with a different byte order.
|
| Changes are also made in all fields and sub-arrays of the data type.
|
| The `new_order` code can be any from the following:
|
| * 'S' - swap dtype from current to opposite endian
| * {'<', 'little'} - little endian
| * {'>', 'big'} - big endian
| * {'=', 'native'} - 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.
|
|
| Returns
| -------
| new_dtype : dtype
| New `dtype` object with the given change to the byte order.
|
| nonzero(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.nonzero`.
|
| prod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.prod`.
|
| ptp(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ptp`.
|
| put(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.put`.
|
| ravel(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ravel`.
|
| repeat(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.repeat`.
|
| reshape(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.reshape`.
|
| resize(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.resize`.
|
| round(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.round`.
|
| searchsorted(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.searchsorted`.
|
| setfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setfield`.
|
| setflags(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setflags`.
|
| sort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sort`.
|
| squeeze(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.squeeze`.
|
| std(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.std`.
|
| sum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sum`.
|
| swapaxes(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.swapaxes`.
|
| take(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.take`.
|
| tobytes(...)
|
| tofile(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tofile`.
|
| tolist(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tolist`.
|
| tostring(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tostring`.
|
| trace(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.trace`.
|
| transpose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.transpose`.
|
| var(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.var`.
|
| view(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.view`.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from generic:
|
| T
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.T`.
|
| __array_interface__
| Array protocol: Python side
|
| __array_priority__
| Array priority.
|
| __array_struct__
| Array protocol: struct
|
| base
| Scalar attribute identical to the corresponding array attribute.
 |
| Please see `ndarray.base`.
|
| data
| Pointer to start of data.
|
| dtype
| Get array data-descriptor.
|
| flags
| The integer value of flags.
|
| flat
| A 1-D view of the scalar.
|
| imag
| The imaginary part of the scalar.
|
| itemsize
| The length of one element in bytes.
|
| nbytes
| The length of the scalar in bytes.
|
| ndim
| The number of array dimensions.
|
| real
| The real part of the scalar.
|
| shape
| Tuple of array dimensions.
|
| size
| The number of elements in the gentype.
|
| strides
| Tuple of bytes steps in each dimension.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from generic:
|
| __hash__ = None

class int16(signedinteger)
| Signed integer type, compatible with C ``short``.
|
| :Character code: ``'h'``
| :Canonical name: `numpy.short`
| :Alias on this platform (win32 AMD64): `numpy.int16`: 16-bit signed integer
(``-32_768`` to ``32_767``).
|
| 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, /)
| True if self else False
|
| __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.
|
| bit_count(...)
| int16.bit_count() -> int
|
| Computes the number of 1-bits in the absolute value of the input.
| Analogous to the builtin `int.bit_count` or ``popcount`` in C++.
|
| Examples
| --------
| >>> np.int16(127).bit_count()
| 7
| >>> np.int16(-127).bit_count()
| 7
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| __class_getitem__(...) from builtins.type
| __class_getitem__(item, /)
|
| Return a parametrized wrapper around the `~numpy.number` type.
|
| .. versionadded:: 1.22
|
| Returns
| -------
| alias : types.GenericAlias
| A parametrized `~numpy.number` type.
|
| Examples
| --------
| >>> from typing import Any
| >>> import numpy as np
|
| >>> np.signedinteger[Any]
| numpy.signedinteger[typing.Any]
|
| See Also
| --------
| :pep:`585` : Type hinting generics in standard collections.
|
| ----------------------------------------------------------------------
| 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__(...)
|
| is_integer(...)
| integer.is_integer() -> bool
|
| Return ``True`` if the number is finite with integral value.
|
| .. versionadded:: 1.22
|
| Examples
| --------
| >>> np.int64(-2).is_integer()
| True
| >>> np.uint32(5).is_integer()
| True
|
| ----------------------------------------------------------------------
| 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(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.all`.
|
| any(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.any`.
|
| argmax(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmax`.
|
| argmin(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmin`.
|
| argsort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argsort`.
|
| astype(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.astype`.
|
| byteswap(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.byteswap`.
|
| choose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.choose`.
|
| clip(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.clip`.
|
| compress(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.compress`.
|
| conj(...)
|
| conjugate(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.conjugate`.
|
| copy(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.copy`.
|
| cumprod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumprod`.
|
| cumsum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumsum`.
|
| diagonal(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.diagonal`.
|
| dump(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dump`.
|
| dumps(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dumps`.
|
| fill(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.fill`.
|
| flatten(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.flatten`.
|
| getfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.getfield`.
|
| item(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.item`.
|
| itemset(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.itemset`.
|
| max(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.max`.
|
| mean(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.mean`.
|
| min(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.min`.
|
| newbyteorder(...)
| newbyteorder(new_order='S', /)
|
| Return a new `dtype` with a different byte order.
|
| Changes are also made in all fields and sub-arrays of the data type.
|
| The `new_order` code can be any from the following:
|
| * 'S' - swap dtype from current to opposite endian
| * {'<', 'little'} - little endian
| * {'>', 'big'} - big endian
| * {'=', 'native'} - 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.
|
|
| Returns
| -------
| new_dtype : dtype
| New `dtype` object with the given change to the byte order.
|
| nonzero(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.nonzero`.
|
| prod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.prod`.
|
| ptp(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ptp`.
|
| put(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.put`.
|
| ravel(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ravel`.
|
| repeat(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.repeat`.
|
| reshape(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.reshape`.
|
| resize(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.resize`.
|
| round(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.round`.
|
| searchsorted(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.searchsorted`.
|
| setfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setfield`.
|
| setflags(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setflags`.
|
| sort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sort`.
|
| squeeze(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.squeeze`.
|
| std(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.std`.
|
| sum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sum`.
|
| swapaxes(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.swapaxes`.
|
| take(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.take`.
|
| tobytes(...)
|
| tofile(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tofile`.
|
| tolist(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tolist`.
|
| tostring(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tostring`.
|
| trace(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.trace`.
|
| transpose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.transpose`.
|
| var(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.var`.
|
| view(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.view`.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from generic:
|
| T
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.T`.
|
| __array_interface__
| Array protocol: Python side
|
| __array_priority__
| Array priority.
|
| __array_struct__
 | Array protocol: struct
|
| base
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.base`.
|
| data
| Pointer to start of data.
|
| dtype
| Get array data-descriptor.
|
| flags
| The integer value of flags.
|
| flat
| A 1-D view of the scalar.
|
| imag
| The imaginary part of the scalar.
|
| itemsize
| The length of one element in bytes.
|
| nbytes
| The length of the scalar in bytes.
|
| ndim
| The number of array dimensions.
|
| real
| The real part of the scalar.
|
| shape
| Tuple of array dimensions.
|
| size
| The number of elements in the gentype.
|
| strides
| Tuple of bytes steps in each dimension.

class int32(signedinteger)
| Signed integer type, compatible with Python `int` and C ``long``.
|
| :Character code: ``'l'``
| :Canonical name: `numpy.int_`
| :Alias on this platform (win32 AMD64): `numpy.int32`: 32-bit signed integer
(``-2_147_483_648`` to ``2_147_483_647``).
|
| 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, /)
| True if self else False
|
| __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.
|
| bit_count(...)
| int32.bit_count() -> int
|
| Computes the number of 1-bits in the absolute value of the input.
| Analogous to the builtin `int.bit_count` or ``popcount`` in C++.
|
| Examples
| --------
| >>> np.int32(127).bit_count()
| 7
| >>> np.int32(-127).bit_count()
| 7
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| __class_getitem__(...) from builtins.type
| __class_getitem__(item, /)
|
| Return a parametrized wrapper around the `~numpy.number` type.
|
| .. versionadded:: 1.22
|
| Returns
| -------
| alias : types.GenericAlias
| A parametrized `~numpy.number` type.
|
| Examples
| --------
| >>> from typing import Any
| >>> import numpy as np
|
| >>> np.signedinteger[Any]
| numpy.signedinteger[typing.Any]
|
| See Also
| --------
| :pep:`585` : Type hinting generics in standard collections.
|
| ----------------------------------------------------------------------
| 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__(...)
|
| is_integer(...)
| integer.is_integer() -> bool
|
| Return ``True`` if the number is finite with integral value.
|
| .. versionadded:: 1.22
|
| Examples
| --------
| >>> np.int64(-2).is_integer()
| True
| >>> np.uint32(5).is_integer()
| True
|
| ----------------------------------------------------------------------
| 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(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.all`.
|
| any(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.any`.
|
| argmax(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmax`.
|
| argmin(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmin`.
|
| argsort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argsort`.
|
| astype(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.astype`.
|
| byteswap(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.byteswap`.
|
| choose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.choose`.
|
| clip(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.clip`.
|
| compress(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.compress`.
|
| conj(...)
|
| conjugate(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.conjugate`.
|
| copy(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.copy`.
|
| cumprod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumprod`.
|
| cumsum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumsum`.
|
| diagonal(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.diagonal`.
|
| dump(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dump`.
|
| dumps(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dumps`.
|
| fill(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.fill`.
|
| flatten(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.flatten`.
|
| getfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.getfield`.
|
| item(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.item`.
|
| itemset(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.itemset`.
|
| max(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.max`.
|
| mean(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.mean`.
|
| min(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.min`.
|
| newbyteorder(...)
| newbyteorder(new_order='S', /)
|
| Return a new `dtype` with a different byte order.
|
| Changes are also made in all fields and sub-arrays of the data type.
|
| The `new_order` code can be any from the following:
|
| * 'S' - swap dtype from current to opposite endian
| * {'<', 'little'} - little endian
| * {'>', 'big'} - big endian
| * {'=', 'native'} - 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.
|
|
| Returns
| -------
| new_dtype : dtype
| New `dtype` object with the given change to the byte order.
|
| nonzero(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.nonzero`.
|
| prod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.prod`.
|
| ptp(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ptp`.
|
| put(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.put`.
|
| ravel(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ravel`.
|
| repeat(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.repeat`.
|
| reshape(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.reshape`.
|
| resize(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.resize`.
|
| round(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.round`.
|
| searchsorted(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.searchsorted`.
|
| setfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setfield`.
|
| setflags(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setflags`.
|
| sort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sort`.
|
| squeeze(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.squeeze`.
|
| std(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.std`.
|
| sum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sum`.
|
| swapaxes(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.swapaxes`.
|
| take(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.take`.
|
| tobytes(...)
|
| tofile(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tofile`.
|
| tolist(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tolist`.
|
| tostring(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tostring`.
|
| trace(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.trace`.
|
| transpose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.transpose`.
|
| var(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.var`.
|
| view(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.view`.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from generic:
|
| T
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.T`.
|
| __array_interface__
| Array protocol: Python side
|
| __array_priority__
| Array priority.
|
| __array_struct__
| Array protocol: struct
 |
| base
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.base`.
|
| data
| Pointer to start of data.
|
| dtype
| Get array data-descriptor.
|
| flags
| The integer value of flags.
|
| flat
| A 1-D view of the scalar.
|
| imag
| The imaginary part of the scalar.
|
| itemsize
| The length of one element in bytes.
|
| nbytes
| The length of the scalar in bytes.
|
| ndim
| The number of array dimensions.
|
| real
| The real part of the scalar.
|
| shape
| Tuple of array dimensions.
|
| size
| The number of elements in the gentype.
|
| strides
| Tuple of bytes steps in each dimension.

class int64(signedinteger)
| Signed integer type, compatible with C ``long long``.
|
| :Character code: ``'q'``
| :Canonical name: `numpy.longlong`
| :Alias on this platform (win32 AMD64): `numpy.int64`: 64-bit signed integer
(``-9_223_372_036_854_775_808`` to ``9_223_372_036_854_775_807``).
| :Alias on this platform (win32 AMD64): `numpy.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, /)
| True if self else False
|
| __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.
|
| bit_count(...)
| int64.bit_count() -> int
|
| Computes the number of 1-bits in the absolute value of the input.
| Analogous to the builtin `int.bit_count` or ``popcount`` in C++.
|
| Examples
| --------
| >>> np.int64(127).bit_count()
| 7
| >>> np.int64(-127).bit_count()
| 7
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| __class_getitem__(...) from builtins.type
| __class_getitem__(item, /)
|
| Return a parametrized wrapper around the `~numpy.number` type.
|
| .. versionadded:: 1.22
|
| Returns
| -------
| alias : types.GenericAlias
| A parametrized `~numpy.number` type.
|
| Examples
| --------
| >>> from typing import Any
| >>> import numpy as np
|
| >>> np.signedinteger[Any]
| numpy.signedinteger[typing.Any]
|
| See Also
| --------
| :pep:`585` : Type hinting generics in standard collections.
|
| ----------------------------------------------------------------------
| 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__(...)
|
| is_integer(...)
| integer.is_integer() -> bool
|
| Return ``True`` if the number is finite with integral value.
|
| .. versionadded:: 1.22
|
| Examples
| --------
| >>> np.int64(-2).is_integer()
| True
| >>> np.uint32(5).is_integer()
| True
|
| ----------------------------------------------------------------------
| 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(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.all`.
|
| any(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.any`.
|
| argmax(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmax`.
|
| argmin(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmin`.
|
| argsort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argsort`.
|
| astype(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.astype`.
|
| byteswap(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.byteswap`.
|
| choose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.choose`.
|
| clip(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.clip`.
|
| compress(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.compress`.
|
| conj(...)
|
| conjugate(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.conjugate`.
|
| copy(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.copy`.
|
| cumprod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumprod`.
|
| cumsum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumsum`.
|
| diagonal(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.diagonal`.
|
| dump(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dump`.
|
| dumps(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dumps`.
|
| fill(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.fill`.
|
| flatten(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.flatten`.
|
| getfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.getfield`.
|
| item(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.item`.
|
| itemset(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.itemset`.
|
| max(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.max`.
|
| mean(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.mean`.
|
| min(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.min`.
|
| newbyteorder(...)
| newbyteorder(new_order='S', /)
|
| Return a new `dtype` with a different byte order.
|
| Changes are also made in all fields and sub-arrays of the data type.
|
| The `new_order` code can be any from the following:
|
| * 'S' - swap dtype from current to opposite endian
| * {'<', 'little'} - little endian
| * {'>', 'big'} - big endian
| * {'=', 'native'} - 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.
|
|
| Returns
| -------
| new_dtype : dtype
| New `dtype` object with the given change to the byte order.
|
| nonzero(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.nonzero`.
|
| prod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.prod`.
|
| ptp(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ptp`.
|
| put(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.put`.
|
| ravel(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ravel`.
|
| repeat(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.repeat`.
|
| reshape(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.reshape`.
|
| resize(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.resize`.
|
| round(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.round`.
|
| searchsorted(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.searchsorted`.
|
| setfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setfield`.
|
| setflags(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setflags`.
|
| sort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sort`.
|
| squeeze(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.squeeze`.
|
| std(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.std`.
|
| sum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sum`.
|
| swapaxes(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.swapaxes`.
|
| take(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.take`.
|
| tobytes(...)
|
| tofile(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tofile`.
|
| tolist(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tolist`.
|
| tostring(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tostring`.
|
| trace(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.trace`.
|
| transpose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.transpose`.
|
| var(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.var`.
|
| view(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.view`.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from generic:
|
| T
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.T`.
|
| __array_interface__
| Array protocol: Python side
|
| __array_priority__
| Array priority.
|
| __array_struct__
 | Array protocol: struct
|
| base
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.base`.
|
| data
| Pointer to start of data.
|
| dtype
| Get array data-descriptor.
|
| flags
| The integer value of flags.
|
| flat
| A 1-D view of the scalar.
|
| imag
| The imaginary part of the scalar.
|
| itemsize
| The length of one element in bytes.
|
| nbytes
| The length of the scalar in bytes.
|
| ndim
| The number of array dimensions.
|
| real
| The real part of the scalar.
|
| shape
| Tuple of array dimensions.
|
| size
| The 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: `numpy.byte`
| :Alias on this platform (win32 AMD64): `numpy.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, /)
| True if self else False
|
| __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.
|
| bit_count(...)
| int8.bit_count() -> int
|
| Computes the number of 1-bits in the absolute value of the input.
| Analogous to the builtin `int.bit_count` or ``popcount`` in C++.
|
| Examples
| --------
| >>> np.int8(127).bit_count()
| 7
| >>> np.int8(-127).bit_count()
| 7
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| __class_getitem__(...) from builtins.type
| __class_getitem__(item, /)
|
| Return a parametrized wrapper around the `~numpy.number` type.
|
| .. versionadded:: 1.22
|
| Returns
| -------
| alias : types.GenericAlias
| A parametrized `~numpy.number` type.
|
| Examples
| --------
| >>> from typing import Any
| >>> import numpy as np
|
| >>> np.signedinteger[Any]
| numpy.signedinteger[typing.Any]
|
| See Also
| --------
| :pep:`585` : Type hinting generics in standard collections.
|
| ----------------------------------------------------------------------
| 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__(...)
|
| is_integer(...)
| integer.is_integer() -> bool
|
| Return ``True`` if the number is finite with integral value.
|
| .. versionadded:: 1.22
|
| Examples
| --------
| >>> np.int64(-2).is_integer()
| True
| >>> np.uint32(5).is_integer()
| True
|
| ----------------------------------------------------------------------
| 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(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.all`.
|
| any(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.any`.
|
| argmax(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmax`.
|
| argmin(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmin`.
|
| argsort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argsort`.
|
| astype(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.astype`.
|
| byteswap(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.byteswap`.
|
| choose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.choose`.
|
| clip(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.clip`.
|
| compress(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.compress`.
|
| conj(...)
|
| conjugate(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.conjugate`.
|
| copy(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.copy`.
|
| cumprod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumprod`.
|
| cumsum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumsum`.
|
| diagonal(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.diagonal`.
|
| dump(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dump`.
|
| dumps(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dumps`.
|
| fill(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.fill`.
|
| flatten(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.flatten`.
|
| getfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.getfield`.
|
| item(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.item`.
|
| itemset(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.itemset`.
|
| max(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.max`.
|
| mean(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.mean`.
|
| min(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.min`.
|
| newbyteorder(...)
| newbyteorder(new_order='S', /)
|
| Return a new `dtype` with a different byte order.
|
| Changes are also made in all fields and sub-arrays of the data type.
|
| The `new_order` code can be any from the following:
|
| * 'S' - swap dtype from current to opposite endian
| * {'<', 'little'} - little endian
| * {'>', 'big'} - big endian
| * {'=', 'native'} - 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.
|
|
| Returns
| -------
| new_dtype : dtype
| New `dtype` object with the given change to the byte order.
|
| nonzero(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.nonzero`.
|
| prod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.prod`.
|
| ptp(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ptp`.
|
| put(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.put`.
|
| ravel(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ravel`.
|
| repeat(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.repeat`.
|
| reshape(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.reshape`.
|
| resize(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.resize`.
|
| round(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.round`.
|
| searchsorted(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.searchsorted`.
|
| setfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setfield`.
|
| setflags(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setflags`.
|
| sort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sort`.
|
| squeeze(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.squeeze`.
|
| std(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.std`.
|
| sum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sum`.
|
| swapaxes(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.swapaxes`.
|
| take(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.take`.
|
| tobytes(...)
|
| tofile(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tofile`.
|
| tolist(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tolist`.
|
| tostring(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tostring`.
|
| trace(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.trace`.
|
| transpose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.transpose`.
|
| var(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.var`.
|
| view(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.view`.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from generic:
|
| T
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.T`.
|
| __array_interface__
| Array protocol: Python side
|
| __array_priority__
| Array priority.
|
| __array_struct__
| Array protocol: struct
 |
| base
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.base`.
|
| data
| Pointer to start of data.
|
| dtype
| Get array data-descriptor.
|
| flags
| The integer value of flags.
|
| flat
| A 1-D view of the scalar.
|
| imag
| The imaginary part of the scalar.
|
| itemsize
| The length of one element in bytes.
|
| nbytes
| The length of the scalar in bytes.
|
| ndim
| The number of array dimensions.
|
| real
| The real part of the scalar.
|
| shape
| Tuple of array dimensions.
|
| size
| The number of elements in the gentype.
|
| strides
| Tuple of bytes steps in each dimension.

int_ = class int32(signedinteger)

| Signed integer type, compatible with Python `int` and C ``long``.
|
| :Character code: ``'l'``
| :Canonical name: `numpy.int_`
| :Alias on this platform (win32 AMD64): `numpy.int32`: 32-bit signed integer
(``-2_147_483_648`` to ``2_147_483_647``).
|
| 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, /)
| True if self else False
|
| __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.
|
| bit_count(...)
| int32.bit_count() -> int
|
| Computes the number of 1-bits in the absolute value of the input.
| Analogous to the builtin `int.bit_count` or ``popcount`` in C++.
|
| Examples
| --------
| >>> np.int32(127).bit_count()
| 7
| >>> np.int32(-127).bit_count()
| 7
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| __class_getitem__(...) from builtins.type
| __class_getitem__(item, /)
|
| Return a parametrized wrapper around the `~numpy.number` type.
|
| .. versionadded:: 1.22
|
| Returns
| -------
| alias : types.GenericAlias
| A parametrized `~numpy.number` type.
|
| Examples
| --------
| >>> from typing import Any
| >>> import numpy as np
|
| >>> np.signedinteger[Any]
| numpy.signedinteger[typing.Any]
|
| See Also
| --------
| :pep:`585` : Type hinting generics in standard collections.
|
| ----------------------------------------------------------------------
| 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__(...)
|
| is_integer(...)
| integer.is_integer() -> bool
|
| Return ``True`` if the number is finite with integral value.
|
| .. versionadded:: 1.22
|
| Examples
| --------
| >>> np.int64(-2).is_integer()
| True
| >>> np.uint32(5).is_integer()
| True
|
| ----------------------------------------------------------------------
| 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(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.all`.
|
| any(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.any`.
|
| argmax(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmax`.
|
| argmin(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmin`.
|
| argsort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argsort`.
|
| astype(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.astype`.
|
| byteswap(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.byteswap`.
|
| choose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.choose`.
|
| clip(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.clip`.
|
| compress(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.compress`.
|
| conj(...)
|
| conjugate(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.conjugate`.
|
| copy(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.copy`.
|
| cumprod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumprod`.
|
| cumsum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumsum`.
|
| diagonal(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.diagonal`.
|
| dump(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dump`.
|
| dumps(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dumps`.
|
| fill(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.fill`.
|
| flatten(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.flatten`.
|
| getfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.getfield`.
|
| item(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.item`.
|
| itemset(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.itemset`.
|
| max(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.max`.
|
| mean(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.mean`.
|
| min(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.min`.
|
| newbyteorder(...)
| newbyteorder(new_order='S', /)
|
| Return a new `dtype` with a different byte order.
|
| Changes are also made in all fields and sub-arrays of the data type.
|
| The `new_order` code can be any from the following:
|
| * 'S' - swap dtype from current to opposite endian
| * {'<', 'little'} - little endian
| * {'>', 'big'} - big endian
| * {'=', 'native'} - 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.
|
|
| Returns
| -------
| new_dtype : dtype
| New `dtype` object with the given change to the byte order.
|
| nonzero(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.nonzero`.
|
| prod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.prod`.
|
| ptp(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ptp`.
|
| put(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.put`.
|
| ravel(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ravel`.
|
| repeat(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.repeat`.
|
| reshape(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.reshape`.
|
| resize(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.resize`.
|
| round(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.round`.
|
| searchsorted(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.searchsorted`.
|
| setfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setfield`.
|
| setflags(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setflags`.
|
| sort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sort`.
|
| squeeze(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.squeeze`.
|
| std(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.std`.
|
| sum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sum`.
|
| swapaxes(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.swapaxes`.
|
| take(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.take`.
|
| tobytes(...)
|
| tofile(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tofile`.
|
| tolist(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tolist`.
|
| tostring(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tostring`.
|
| trace(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.trace`.
|
| transpose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.transpose`.
|
| var(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.var`.
|
| view(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.view`.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from generic:
|
| T
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.T`.
|
| __array_interface__
| Array protocol: Python side
|
| __array_priority__
| Array priority.
|
| __array_struct__
| Array protocol: struct
|
| base
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.base`.
|
| data
| Pointer to start of data.
|
| dtype
| Get array data-descriptor.
|
| flags
| The integer value of flags.
|
| flat
| A 1-D view of the scalar.
|
| imag
| The imaginary part of the scalar.
|
| itemsize
| The length of one element in bytes.
|
| nbytes
| The length of the scalar in bytes.
|
| ndim
| The number of array dimensions.
|
| real
| The real part of the scalar.
|
| shape
| Tuple of array dimensions.
|
| size
| The number of elements in the gentype.
|
| strides
| Tuple of bytes steps in each dimension.

class intc(signedinteger)
| Signed integer type, compatible with C ``int``.
|
| :Character code: ``'i'``
|
| Method resolution order:
| intc
| 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, /)
| True if self else False
|
| __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.
|
| bit_count(...)
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| __class_getitem__(...) from builtins.type
| __class_getitem__(item, /)
|
| Return a parametrized wrapper around the `~numpy.number` type.
|
| .. versionadded:: 1.22
|
| Returns
| -------
| alias : types.GenericAlias
| A parametrized `~numpy.number` type.
|
| Examples
| --------
| >>> from typing import Any
| >>> import numpy as np
|
| >>> np.signedinteger[Any]
| numpy.signedinteger[typing.Any]
|
| See Also
| --------
| :pep:`585` : Type hinting generics in standard collections.
|
| ----------------------------------------------------------------------
| 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__(...)
|
| is_integer(...)
| integer.is_integer() -> bool
|
| Return ``True`` if the number is finite with integral value.
|
| .. versionadded:: 1.22
|
| Examples
| --------
| >>> np.int64(-2).is_integer()
| True
| >>> np.uint32(5).is_integer()
| True
|
| ----------------------------------------------------------------------
| 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(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.all`.
|
| any(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.any`.
|
| argmax(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmax`.
|
| argmin(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmin`.
|
| argsort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argsort`.
|
| astype(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.astype`.
|
| byteswap(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.byteswap`.
|
| choose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.choose`.
|
| clip(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.clip`.
|
| compress(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.compress`.
|
| conj(...)
|
| conjugate(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.conjugate`.
|
| copy(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.copy`.
|
| cumprod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumprod`.
|
| cumsum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumsum`.
|
| diagonal(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.diagonal`.
|
| dump(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dump`.
|
| dumps(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dumps`.
|
| fill(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.fill`.
|
| flatten(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.flatten`.
|
| getfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.getfield`.
|
| item(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.item`.
|
| itemset(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.itemset`.
|
| max(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.max`.
|
| mean(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.mean`.
|
| min(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.min`.
|
| newbyteorder(...)
| newbyteorder(new_order='S', /)
|
| Return a new `dtype` with a different byte order.
|
| Changes are also made in all fields and sub-arrays of the data type.
|
| The `new_order` code can be any from the following:
|
| * 'S' - swap dtype from current to opposite endian
| * {'<', 'little'} - little endian
| * {'>', 'big'} - big endian
| * {'=', 'native'} - 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.
|
|
| Returns
| -------
| new_dtype : dtype
| New `dtype` object with the given change to the byte order.
|
| nonzero(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.nonzero`.
|
| prod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.prod`.
|
| ptp(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ptp`.
|
| put(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.put`.
|
| ravel(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ravel`.
|
| repeat(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.repeat`.
|
| reshape(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.reshape`.
|
| resize(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.resize`.
|
| round(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.round`.
|
| searchsorted(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.searchsorted`.
|
| setfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setfield`.
|
| setflags(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setflags`.
|
| sort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sort`.
|
| squeeze(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.squeeze`.
|
| std(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.std`.
|
| sum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sum`.
|
| swapaxes(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.swapaxes`.
|
| take(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.take`.
|
| tobytes(...)
|
| tofile(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tofile`.
|
| tolist(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tolist`.
|
| tostring(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tostring`.
|
| trace(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.trace`.
|
| transpose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.transpose`.
|
| var(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.var`.
|
| view(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.view`.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from generic:
|
| T
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.T`.
|
| __array_interface__
| Array protocol: Python side
|
| __array_priority__
| Array priority.
|
| __array_struct__
| Array protocol: struct
|
| base
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.base`.
|
| data
| Pointer to start of data.
|
| dtype
| Get array data-descriptor.
|
| flags
| The integer value of flags.
|
| flat
| A 1-D view of the scalar.
|
| imag
| The imaginary part of the scalar.
|
| itemsize
| The length of one element in bytes.
|
| nbytes
| The length of the scalar in bytes.
|
| ndim
| The number of array dimensions.
|
| real
| The real part of the scalar.
|
| shape
| Tuple of array dimensions.
|
| size
| The 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__(...)
|
| is_integer(...)
| integer.is_integer() -> bool
|
| Return ``True`` if the number is finite with integral value.
|
| .. versionadded:: 1.22
|
| Examples
| --------
| >>> np.int64(-2).is_integer()
| True
| >>> np.uint32(5).is_integer()
| True
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| denominator
| denominator of value (1)
|
| numerator
| numerator of value (the value itself)
|
| ----------------------------------------------------------------------
| Class methods inherited from number:
|
| __class_getitem__(...) from builtins.type
| __class_getitem__(item, /)
|
| Return a parametrized wrapper around the `~numpy.number` type.
|
| .. versionadded:: 1.22
|
| Returns
| -------
| alias : types.GenericAlias
| A parametrized `~numpy.number` type.
|
| Examples
| --------
| >>> from typing import Any
| >>> import numpy as np
|
| >>> np.signedinteger[Any]
| numpy.signedinteger[typing.Any]
|
| See Also
| --------
| :pep:`585` : Type hinting generics in standard collections.
|
| ----------------------------------------------------------------------
| 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, /)
| True if self else False
|
| __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(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.all`.
|
| any(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.any`.
|
| argmax(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmax`.
|
| argmin(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmin`.
|
| argsort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argsort`.
|
| astype(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.astype`.
|
| byteswap(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.byteswap`.
|
| choose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.choose`.
|
| clip(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.clip`.
|
| compress(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.compress`.
|
| conj(...)
|
| conjugate(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.conjugate`.
|
| copy(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.copy`.
|
| cumprod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumprod`.
|
| cumsum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumsum`.
|
| diagonal(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.diagonal`.
|
| dump(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dump`.
|
| dumps(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dumps`.
|
| fill(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.fill`.
|
| flatten(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.flatten`.
|
| getfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.getfield`.
|
| item(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.item`.
|
| itemset(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.itemset`.
|
| max(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.max`.
|
| mean(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.mean`.
|
| min(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.min`.
|
| newbyteorder(...)
| newbyteorder(new_order='S', /)
|
| Return a new `dtype` with a different byte order.
|
| Changes are also made in all fields and sub-arrays of the data type.
|
| The `new_order` code can be any from the following:
|
| * 'S' - swap dtype from current to opposite endian
| * {'<', 'little'} - little endian
| * {'>', 'big'} - big endian
| * {'=', 'native'} - 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.
|
|
| Returns
| -------
| new_dtype : dtype
| New `dtype` object with the given change to the byte order.
|
| nonzero(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.nonzero`.
|
| prod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.prod`.
|
| ptp(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ptp`.
|
| put(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.put`.
|
| ravel(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ravel`.
|
| repeat(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.repeat`.
|
| reshape(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.reshape`.
|
| resize(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.resize`.
|
| round(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.round`.
|
| searchsorted(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.searchsorted`.
|
| setfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setfield`.
|
| setflags(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setflags`.
|
| sort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sort`.
|
| squeeze(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.squeeze`.
|
| std(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.std`.
|
| sum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sum`.
|
| swapaxes(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.swapaxes`.
|
| take(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.take`.
|
| tobytes(...)
|
| tofile(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tofile`.
|
| tolist(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tolist`.
|
| tostring(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tostring`.
|
| trace(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.trace`.
|
| transpose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.transpose`.
|
| var(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.var`.
|
| view(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.view`.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from generic:
|
| T
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.T`.
|
| __array_interface__
| Array protocol: Python side
|
| __array_priority__
| Array priority.
|
| __array_struct__
| Array protocol: struct
 |
| base
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.base`.
|
| data
| Pointer to start of data.
|
| dtype
| Get array data-descriptor.
|
| flags
| The integer value of flags.
|
| flat
| A 1-D view of the scalar.
|
| imag
| The imaginary part of the scalar.
|
| itemsize
| The length of one element in bytes.
|
| nbytes
| The length of the scalar in bytes.
|
| ndim
| The number of array dimensions.
|
| real
| The real part of the scalar.
|
| shape
| Tuple of array dimensions.
|
| size
| The 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 C ``long long``.
|
| :Character code: ``'q'``
| :Canonical name: `numpy.longlong`
| :Alias on this platform (win32 AMD64): `numpy.int64`: 64-bit signed integer
(``-9_223_372_036_854_775_808`` to ``9_223_372_036_854_775_807``).
| :Alias on this platform (win32 AMD64): `numpy.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, /)
| True if self else False
|
| __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.
|
| bit_count(...)
| int64.bit_count() -> int
|
| Computes the number of 1-bits in the absolute value of the input.
| Analogous to the builtin `int.bit_count` or ``popcount`` in C++.
|
| Examples
| --------
| >>> np.int64(127).bit_count()
| 7
| >>> np.int64(-127).bit_count()
| 7
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| __class_getitem__(...) from builtins.type
| __class_getitem__(item, /)
|
| Return a parametrized wrapper around the `~numpy.number` type.
|
| .. versionadded:: 1.22
|
| Returns
| -------
| alias : types.GenericAlias
| A parametrized `~numpy.number` type.
|
| Examples
| --------
| >>> from typing import Any
| >>> import numpy as np
|
| >>> np.signedinteger[Any]
| numpy.signedinteger[typing.Any]
|
| See Also
| --------
| :pep:`585` : Type hinting generics in standard collections.
|
| ----------------------------------------------------------------------
| 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__(...)
|
| is_integer(...)
| integer.is_integer() -> bool
|
| Return ``True`` if the number is finite with integral value.
|
| .. versionadded:: 1.22
|
| Examples
| --------
| >>> np.int64(-2).is_integer()
| True
| >>> np.uint32(5).is_integer()
| True
|
| ----------------------------------------------------------------------
| 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(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.all`.
|
| any(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.any`.
|
| argmax(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmax`.
|
| argmin(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmin`.
|
| argsort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argsort`.
|
| astype(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.astype`.
|
| byteswap(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.byteswap`.
|
| choose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.choose`.
|
| clip(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.clip`.
|
| compress(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.compress`.
|
| conj(...)
|
| conjugate(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.conjugate`.
|
| copy(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.copy`.
|
| cumprod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumprod`.
|
| cumsum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumsum`.
|
| diagonal(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.diagonal`.
|
| dump(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dump`.
|
| dumps(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dumps`.
|
| fill(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.fill`.
|
| flatten(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.flatten`.
|
| getfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.getfield`.
|
| item(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.item`.
|
| itemset(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.itemset`.
|
| max(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.max`.
|
| mean(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.mean`.
|
| min(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.min`.
|
| newbyteorder(...)
| newbyteorder(new_order='S', /)
|
| Return a new `dtype` with a different byte order.
|
| Changes are also made in all fields and sub-arrays of the data type.
|
| The `new_order` code can be any from the following:
|
| * 'S' - swap dtype from current to opposite endian
| * {'<', 'little'} - little endian
| * {'>', 'big'} - big endian
| * {'=', 'native'} - 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.
|
|
| Returns
| -------
| new_dtype : dtype
| New `dtype` object with the given change to the byte order.
|
| nonzero(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.nonzero`.
|
| prod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.prod`.
|
| ptp(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ptp`.
|
| put(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.put`.
|
| ravel(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ravel`.
|
| repeat(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.repeat`.
|
| reshape(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.reshape`.
|
| resize(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.resize`.
|
| round(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.round`.
|
| searchsorted(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.searchsorted`.
|
| setfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setfield`.
|
| setflags(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setflags`.
|
| sort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sort`.
|
| squeeze(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.squeeze`.
|
| std(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.std`.
|
| sum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sum`.
|
| swapaxes(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.swapaxes`.
|
| take(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.take`.
|
| tobytes(...)
|
| tofile(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tofile`.
|
| tolist(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tolist`.
|
| tostring(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tostring`.
|
| trace(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.trace`.
|
| transpose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.transpose`.
|
| var(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.var`.
|
| view(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.view`.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from generic:
|
| T
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.T`.
|
| __array_interface__
| Array protocol: Python side
|
| __array_priority__
| Array priority.
|
| __array_struct__
| Array protocol: struct
|
| base
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.base`.
|
| data
| Pointer to start of data.
|
| dtype
| Get array data-descriptor.
|
| flags
| The integer value of flags.
|
| flat
| A 1-D view of the scalar.
|
| imag
| The imaginary part of the scalar.
|
| itemsize
| The length of one element in bytes.
|
| nbytes
| The length of the scalar in bytes.
|
| ndim
| The number of array dimensions.
|
| real
| The real part of the scalar.
|
| shape
| Tuple of array dimensions.
|
| size
| The number of elements in the gentype.
|
| strides
| Tuple of bytes steps in each dimension.

longcomplex = class clongdouble(complexfloating)

| Complex number type composed of two extended-precision floating-point
| numbers.
|
| :Character code: ``'G'``
| :Alias: `numpy.clongfloat`
| :Alias: `numpy.longcomplex`
|
| Method resolution order:
| clongdouble
| complexfloating
| inexact
| number
| generic
| builtins.object
|
| Methods defined here:
|
| __abs__(self, /)
| abs(self)
|
| __add__(self, value, /)
| Return self+value.
|
| __bool__(self, /)
| True if self else False
|
| __complex__(...)
|
| __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.
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| __class_getitem__(...) from builtins.type
| __class_getitem__(item, /)
|
| Return a parametrized wrapper around the `~numpy.number` type.
|
| .. versionadded:: 1.22
|
| Returns
| -------
| alias : types.GenericAlias
| A parametrized `~numpy.number` type.
|
| Examples
| --------
| >>> from typing import Any
| >>> import numpy as np
|
| >>> np.signedinteger[Any]
| numpy.signedinteger[typing.Any]
|
| See Also
| --------
| :pep:`585` : Type hinting generics in standard collections.
|
| ----------------------------------------------------------------------
| 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__(...)
|
| __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(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.all`.
|
| any(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.any`.
|
| argmax(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmax`.
|
| argmin(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmin`.
|
| argsort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argsort`.
|
| astype(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.astype`.
|
| byteswap(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.byteswap`.
|
| choose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.choose`.
|
| clip(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.clip`.
|
| compress(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.compress`.
|
| conj(...)
|
| conjugate(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.conjugate`.
|
| copy(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.copy`.
|
| cumprod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumprod`.
|
| cumsum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumsum`.
|
| diagonal(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.diagonal`.
|
| dump(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dump`.
|
| dumps(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dumps`.
|
| fill(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.fill`.
|
| flatten(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.flatten`.
|
| getfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.getfield`.
|
| item(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.item`.
|
| itemset(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.itemset`.
|
| max(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.max`.
|
| mean(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.mean`.
|
| min(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.min`.
|
| newbyteorder(...)
| newbyteorder(new_order='S', /)
|
| Return a new `dtype` with a different byte order.
|
| Changes are also made in all fields and sub-arrays of the data type.
|
| The `new_order` code can be any from the following:
|
| * 'S' - swap dtype from current to opposite endian
| * {'<', 'little'} - little endian
| * {'>', 'big'} - big endian
| * {'=', 'native'} - 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.
|
|
| Returns
| -------
| new_dtype : dtype
| New `dtype` object with the given change to the byte order.
|
| nonzero(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.nonzero`.
|
| prod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.prod`.
|
| ptp(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ptp`.
|
| put(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.put`.
|
| ravel(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ravel`.
|
| repeat(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.repeat`.
|
| reshape(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.reshape`.
|
| resize(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.resize`.
|
| round(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.round`.
|
| searchsorted(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.searchsorted`.
|
| setfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setfield`.
|
| setflags(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setflags`.
|
| sort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sort`.
|
| squeeze(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.squeeze`.
|
| std(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.std`.
|
| sum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sum`.
|
| swapaxes(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.swapaxes`.
|
| take(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.take`.
|
| tobytes(...)
|
| tofile(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tofile`.
|
| tolist(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tolist`.
|
| tostring(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tostring`.
|
| trace(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.trace`.
|
| transpose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.transpose`.
|
| var(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.var`.
|
| view(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.view`.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from generic:
|
| T
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.T`.
|
| __array_interface__
| Array protocol: Python side
|
| __array_priority__
| Array priority.
|
| __array_struct__
| Array protocol: struct
|
| base
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.base`.
|
| data
| Pointer to start of data.
|
| dtype
| Get array data-descriptor.
|
| flags
| The integer value of flags.
|
| flat
| A 1-D view of the scalar.
|
| imag
| The imaginary part of the scalar.
|
| itemsize
| The length of one element in bytes.
|
| nbytes
| The length of the scalar in bytes.
|
| ndim
| The number of array dimensions.
|
| real
| The real part of the scalar.
|
| shape
| Tuple of array dimensions.
|
| size
| The number of elements in the gentype.
|
| strides
| Tuple of bytes steps in each dimension.

class longdouble(floating)
| Extended-precision floating-point number type, compatible with C
| ``long double`` but not necessarily with IEEE 754 quadruple-precision.
|
| :Character code: ``'g'``
| :Alias: `numpy.longfloat`
|
| Method resolution order:
| longdouble
| floating
| inexact
| number
| generic
| builtins.object
|
| Methods defined here:
|
| __abs__(self, /)
| abs(self)
|
| __add__(self, value, /)
| Return self+value.
|
| __bool__(self, /)
| True if self else False
|
| __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)
|
| is_integer(...)
| longdouble.is_integer() -> bool
|
| Return ``True`` if the floating point number is finite with integral
| value, and ``False`` otherwise.
|
| .. versionadded:: 1.22
|
| Examples
| --------
| >>> np.longdouble(-2.0).is_integer()
| True
| >>> np.longdouble(3.2).is_integer()
| False
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| __class_getitem__(...) from builtins.type
| __class_getitem__(item, /)
|
| Return a parametrized wrapper around the `~numpy.number` type.
|
| .. versionadded:: 1.22
|
| Returns
| -------
| alias : types.GenericAlias
| A parametrized `~numpy.number` type.
|
| Examples
| --------
| >>> from typing import Any
| >>> import numpy as np
|
| >>> np.signedinteger[Any]
| numpy.signedinteger[typing.Any]
|
| See Also
| --------
| :pep:`585` : Type hinting generics in standard collections.
|
| ----------------------------------------------------------------------
| 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(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.all`.
|
| any(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.any`.
|
| argmax(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmax`.
|
| argmin(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmin`.
|
| argsort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argsort`.
|
| astype(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.astype`.
|
| byteswap(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.byteswap`.
|
| choose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.choose`.
|
| clip(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.clip`.
|
| compress(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.compress`.
|
| conj(...)
|
| conjugate(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.conjugate`.
|
| copy(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.copy`.
|
| cumprod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumprod`.
|
| cumsum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumsum`.
|
| diagonal(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.diagonal`.
|
| dump(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dump`.
|
| dumps(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dumps`.
|
| fill(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.fill`.
|
| flatten(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.flatten`.
|
| getfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.getfield`.
|
| item(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.item`.
|
| itemset(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.itemset`.
|
| max(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.max`.
|
| mean(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.mean`.
|
| min(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.min`.
|
| newbyteorder(...)
| newbyteorder(new_order='S', /)
|
| Return a new `dtype` with a different byte order.
|
| Changes are also made in all fields and sub-arrays of the data type.
|
| The `new_order` code can be any from the following:
|
| * 'S' - swap dtype from current to opposite endian
| * {'<', 'little'} - little endian
| * {'>', 'big'} - big endian
| * {'=', 'native'} - 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.
|
|
| Returns
| -------
| new_dtype : dtype
| New `dtype` object with the given change to the byte order.
|
| nonzero(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.nonzero`.
|
| prod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.prod`.
|
| ptp(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ptp`.
|
| put(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.put`.
|
| ravel(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ravel`.
|
| repeat(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.repeat`.
|
| reshape(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.reshape`.
|
| resize(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.resize`.
|
| round(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.round`.
|
| searchsorted(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.searchsorted`.
|
| setfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setfield`.
|
| setflags(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setflags`.
|
| sort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sort`.
|
| squeeze(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.squeeze`.
|
| std(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.std`.
|
| sum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sum`.
|
| swapaxes(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.swapaxes`.
|
| take(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.take`.
|
| tobytes(...)
|
| tofile(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tofile`.
|
| tolist(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tolist`.
|
| tostring(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tostring`.
|
| trace(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.trace`.
|
| transpose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.transpose`.
|
| var(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.var`.
|
| view(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.view`.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from generic:
|
| T
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.T`.
|
| __array_interface__
| Array protocol: Python side
|
| __array_priority__
| Array priority.
|
| __array_struct__
| Array protocol: struct
|
| base
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.base`.
|
| data
| Pointer to start of data.
|
| dtype
| Get array data-descriptor.
|
| flags
| The integer value of flags.
|
| flat
| A 1-D view of the scalar.
|
| imag
| The imaginary part of the scalar.
|
| itemsize
| The length of one element in bytes.
|
| nbytes
| The length of the scalar in bytes.
|
| ndim
| The number of array dimensions.
|
| real
| The real part of the scalar.
|
| shape
| Tuple of array dimensions.
|
| size
| The number of elements in the gentype.
|
| strides
| Tuple of bytes steps in each dimension.

longfloat = class longdouble(floating)

| Extended-precision floating-point number type, compatible with C
| ``long double`` but not necessarily with IEEE 754 quadruple-precision.
|
| :Character code: ``'g'``
| :Alias: `numpy.longfloat`
|
| Method resolution order:
| longdouble
| floating
| inexact
| number
| generic
| builtins.object
|
| Methods defined here:
|
| __abs__(self, /)
| abs(self)
|
| __add__(self, value, /)
| Return self+value.
|
| __bool__(self, /)
| True if self else False
|
| __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)
|
| is_integer(...)
| longdouble.is_integer() -> bool
|
| Return ``True`` if the floating point number is finite with integral
| value, and ``False`` otherwise.
|
| .. versionadded:: 1.22
|
| Examples
| --------
| >>> np.longdouble(-2.0).is_integer()
| True
| >>> np.longdouble(3.2).is_integer()
| False
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| __class_getitem__(...) from builtins.type
| __class_getitem__(item, /)
|
| Return a parametrized wrapper around the `~numpy.number` type.
|
| .. versionadded:: 1.22
|
| Returns
| -------
| alias : types.GenericAlias
| A parametrized `~numpy.number` type.
|
| Examples
| --------
| >>> from typing import Any
| >>> import numpy as np
|
| >>> np.signedinteger[Any]
| numpy.signedinteger[typing.Any]
|
| See Also
| --------
| :pep:`585` : Type hinting generics in standard collections.
|
| ----------------------------------------------------------------------
| 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(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.all`.
|
| any(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.any`.
|
| argmax(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmax`.
|
| argmin(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmin`.
|
| argsort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argsort`.
|
| astype(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.astype`.
|
| byteswap(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.byteswap`.
|
| choose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.choose`.
|
| clip(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.clip`.
|
| compress(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.compress`.
|
| conj(...)
|
| conjugate(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.conjugate`.
|
| copy(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.copy`.
|
| cumprod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumprod`.
|
| cumsum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumsum`.
|
| diagonal(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.diagonal`.
|
| dump(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dump`.
|
| dumps(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dumps`.
|
| fill(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.fill`.
|
| flatten(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.flatten`.
|
| getfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.getfield`.
|
| item(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.item`.
|
| itemset(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.itemset`.
|
| max(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.max`.
|
| mean(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.mean`.
|
| min(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.min`.
|
| newbyteorder(...)
| newbyteorder(new_order='S', /)
|
| Return a new `dtype` with a different byte order.
|
| Changes are also made in all fields and sub-arrays of the data type.
|
| The `new_order` code can be any from the following:
|
| * 'S' - swap dtype from current to opposite endian
| * {'<', 'little'} - little endian
| * {'>', 'big'} - big endian
| * {'=', 'native'} - 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.
|
|
| Returns
| -------
| new_dtype : dtype
| New `dtype` object with the given change to the byte order.
|
| nonzero(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.nonzero`.
|
| prod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.prod`.
|
| ptp(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ptp`.
|
| put(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.put`.
|
| ravel(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ravel`.
|
| repeat(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.repeat`.
|
| reshape(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.reshape`.
|
| resize(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.resize`.
|
| round(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.round`.
|
| searchsorted(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.searchsorted`.
|
| setfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setfield`.
|
| setflags(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setflags`.
|
| sort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sort`.
|
| squeeze(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.squeeze`.
|
| std(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.std`.
|
| sum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sum`.
|
| swapaxes(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.swapaxes`.
|
| take(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.take`.
|
| tobytes(...)
|
| tofile(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tofile`.
|
| tolist(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tolist`.
|
| tostring(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tostring`.
|
| trace(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.trace`.
|
| transpose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.transpose`.
|
| var(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.var`.
|
| view(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.view`.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from generic:
|
| T
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.T`.
|
| __array_interface__
| Array protocol: Python side
|
| __array_priority__
| Array priority.
|
| __array_struct__
| Array protocol: struct
 |
| base
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.base`.
|
| data
| Pointer to start of data.
|
| dtype
| Get array data-descriptor.
|
| flags
| The integer value of flags.
|
| flat
| A 1-D view of the scalar.
|
| imag
| The imaginary part of the scalar.
|
| itemsize
| The length of one element in bytes.
|
| nbytes
| The length of the scalar in bytes.
|
| ndim
| The number of array dimensions.
|
| real
| The real part of the scalar.
|
| shape
| Tuple of array dimensions.
|
| size
| The number of elements in the gentype.
|
| strides
| Tuple of bytes steps in each dimension.

longlong = class int64(signedinteger)

| Signed integer type, compatible with C ``long long``.
|
| :Character code: ``'q'``
| :Canonical name: `numpy.longlong`
| :Alias on this platform (win32 AMD64): `numpy.int64`: 64-bit signed integer
(``-9_223_372_036_854_775_808`` to ``9_223_372_036_854_775_807``).
| :Alias on this platform (win32 AMD64): `numpy.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, /)
| True if self else False
|
| __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.
|
| bit_count(...)
| int64.bit_count() -> int
|
| Computes the number of 1-bits in the absolute value of the input.
| Analogous to the builtin `int.bit_count` or ``popcount`` in C++.
|
| Examples
| --------
| >>> np.int64(127).bit_count()
| 7
| >>> np.int64(-127).bit_count()
| 7
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| __class_getitem__(...) from builtins.type
| __class_getitem__(item, /)
|
| Return a parametrized wrapper around the `~numpy.number` type.
|
| .. versionadded:: 1.22
|
| Returns
| -------
| alias : types.GenericAlias
| A parametrized `~numpy.number` type.
|
| Examples
| --------
| >>> from typing import Any
| >>> import numpy as np
|
| >>> np.signedinteger[Any]
| numpy.signedinteger[typing.Any]
|
| See Also
| --------
| :pep:`585` : Type hinting generics in standard collections.
|
| ----------------------------------------------------------------------
| 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__(...)
|
| is_integer(...)
| integer.is_integer() -> bool
|
| Return ``True`` if the number is finite with integral value.
|
| .. versionadded:: 1.22
|
| Examples
| --------
| >>> np.int64(-2).is_integer()
| True
| >>> np.uint32(5).is_integer()
| True
|
| ----------------------------------------------------------------------
| 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(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.all`.
|
| any(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.any`.
|
| argmax(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmax`.
|
| argmin(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmin`.
|
| argsort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argsort`.
|
| astype(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.astype`.
|
| byteswap(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.byteswap`.
|
| choose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.choose`.
|
| clip(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.clip`.
|
| compress(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.compress`.
|
| conj(...)
|
| conjugate(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.conjugate`.
|
| copy(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.copy`.
|
| cumprod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumprod`.
|
| cumsum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumsum`.
|
| diagonal(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.diagonal`.
|
| dump(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dump`.
|
| dumps(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dumps`.
|
| fill(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.fill`.
|
| flatten(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.flatten`.
|
| getfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.getfield`.
|
| item(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.item`.
|
| itemset(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.itemset`.
|
| max(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.max`.
|
| mean(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.mean`.
|
| min(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.min`.
|
| newbyteorder(...)
| newbyteorder(new_order='S', /)
|
| Return a new `dtype` with a different byte order.
|
| Changes are also made in all fields and sub-arrays of the data type.
|
| The `new_order` code can be any from the following:
|
| * 'S' - swap dtype from current to opposite endian
| * {'<', 'little'} - little endian
| * {'>', 'big'} - big endian
| * {'=', 'native'} - 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.
|
|
| Returns
| -------
| new_dtype : dtype
| New `dtype` object with the given change to the byte order.
|
| nonzero(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.nonzero`.
|
| prod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.prod`.
|
| ptp(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ptp`.
|
| put(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.put`.
|
| ravel(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ravel`.
|
| repeat(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.repeat`.
|
| reshape(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.reshape`.
|
| resize(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.resize`.
|
| round(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.round`.
|
| searchsorted(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.searchsorted`.
|
| setfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setfield`.
|
| setflags(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setflags`.
|
| sort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sort`.
|
| squeeze(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.squeeze`.
|
| std(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.std`.
|
| sum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sum`.
|
| swapaxes(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.swapaxes`.
|
| take(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.take`.
|
| tobytes(...)
|
| tofile(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tofile`.
|
| tolist(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tolist`.
|
| tostring(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tostring`.
|
| trace(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.trace`.
|
| transpose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.transpose`.
|
| var(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.var`.
|
| view(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.view`.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from generic:
|
| T
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.T`.
|
| __array_interface__
| Array protocol: Python side
|
| __array_priority__
| Array priority.
|
| __array_struct__
| Array protocol: struct
|
| base
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.base`.
|
| data
| Pointer to start of data.
|
| dtype
| Get array data-descriptor.
|
| flags
| The integer value of flags.
|
| flat
| A 1-D view of the scalar.
|
| imag
| The imaginary part of the scalar.
|
| itemsize
| The length of one element in bytes.
|
| nbytes
| The length of the scalar in bytes.
|
| ndim
| The number of array dimensions.
|
| real
| The real part of the scalar.
|
| shape
| Tuple of array dimensions.
|
| size
| The 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)
| a.__array_finalize__(obj, /)
|
| Present so subclasses can call super. Does nothing.
|
| __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 axes of length one 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:
|
| __annotations__ = {}
|
| __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], /)
|
| 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__(array[, context], /)
|
| Returns a view of `array` with the same type as self.
|
 | __array_ufunc__(...)
|
| __array_wrap__(...)
| a.__array_wrap__(array[, context], /)
|
| Returns a view of `array` with the same type as self.
|
| __bool__(self, /)
| True if self else False
|
| __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, /)
|
| Used if :func:`copy.deepcopy` is called on an array.
|
| __delitem__(self, key, /)
| Delete self[key].
|
| __divmod__(self, value, /)
| Return divmod(self, value).
|
| __dlpack__(...)
| a.__dlpack__(*, stream=None)
|
| DLPack Protocol: Part of the Array API.
|
| __dlpack_device__(...)
| a.__dlpack_device__()
|
| DLPack Protocol: Part of the Array API.
|
| __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, and this function always passes sub-classes through.)
|
| See also
| --------
| numpy.copy : Similar function with different default behavior
| numpy.copyto
|
| Notes
| -----
| This function is the preferred method for creating an array copy. The
| function :func:`numpy.copy` is similar, but it defaults to using order
'K',
| and will not pass sub-classes through by default.
|
| 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(...)
|
| 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 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.])
|
| Fill expects a scalar value and always behaves the same as assigning
| to a single array element. The following is a rare example where this
| distinction is important:
|
| >>> a = np.array([None, None], dtype=object)
| >>> a[0] = np.array(3)
| >>> a
| array([array(3), None], dtype=object)
| >>> a.fill(np.array(3))
| >>> a
| array([array(3), array(3)], dtype=object)
|
| Where other forms of assignments will unpack the array being assigned:
|
| >>> a[...] = np.array(3)
| >>> a
| array([3, 3], dtype=object)
|
| 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
| * {'<', 'little'} - little endian
| * {'>', 'big'} - big endian
| * {'=', 'native'} - native order, equivalent to `sys.byteorder`
| * {'|', 'I'} - ignore (no change to byte order)
|
| The default value ('S') results in swapping the current
| byte order.
|
|
| 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.
|
| .. deprecated:: 1.22.0
| Passing booleans as index is deprecated.
| 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 partitioned 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,
| 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 flag can never be set
| to True. The flag WRITEABLE can only be set to True if the array owns
its
| own memory, or the ultimate owner of the memory exposes a writeable
buffer
| interface, or is a string. (The exception for string is made so that
| unpickling can be done without copying memory.)
|
| Parameters
| ----------
| write : bool, optional
| Describes whether or not `a` can be written to.
| align : bool, optional
| Describes whether or not `a` is aligned properly for its type.
| uic : bool, optional
| Describes whether or not `a` is a copy of another "base" array.
|
| Notes
| -----
 | Array flags provide information about how the memory area used
| for the array is to be interpreted. There are 7 Boolean flags
| in use, only four of which can be changed by the user:
| WRITEBACKIFCOPY, 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);
|
| 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
| >>> y.setflags(write=0, align=0)
| >>> y.flags
| C_CONTIGUOUS : True
| F_CONTIGUOUS : False
| OWNDATA : True
| WRITEABLE : False
| ALIGNED : False
| WRITEBACKIFCOPY : 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 is produced in C-order by default.
| This behavior is controlled by the ``order`` parameter.
|
| .. versionadded:: 1.9.0
|
| Parameters
| ----------
| order : {'C', 'F', 'A'}, optional
| Controls the memory layout of the bytes object. 'C' means C-order,
| 'F' means F-order, 'A' (short for *Any*) means 'F' if `a` is
| Fortran contiguous, 'C' otherwise. Default is 'C'.
|
| Returns
| -------
| s : bytes
| Python bytes exhibiting a copy of `a`'s raw data.
|
| See also
| --------
| frombuffer
| Inverse of this operation, construct a 1-dimensional array from
Python
| bytes.
|
| 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.
|
| Refer to `numpy.transpose` for full documentation.
|
| 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 that the
| array's `i`-th axis becomes the transposed array'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
| -------
| p : ndarray
| View of the array with its axes suitably permuted.
|
| See Also
| --------
| transpose : Equivalent function.
| 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]])
|
| >>> a = np.array([1, 2, 3, 4])
| >>> a
| array([1, 2, 3, 4])
| >>> a.transpose()
| array([1, 2, 3, 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 last axis of ``a`` must be
| contiguous. This axis will be resized in the result.
|
| .. versionchanged:: 1.23.0
| Only the last axis needs to be contiguous. Previously, the entire
array
| had to be C-contiguous.
|
| 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[:, ::2]
| >>> y
| array([[1, 3],
| [4, 6]], 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 last axis
must be contiguous
| >>> z = y.copy()
| >>> z.view(dtype=[('width', np.int16), ('length', np.int16)])
| array([[(1, 3)],
| [(4, 6)]], dtype=[('width', '<i2'), ('length', '<i2')])
|
| However, views that change dtype are totally fine for arrays with a
| contiguous last axis, even if the rest of the axes are not C-
contiguous:
|
| >>> x = np.arange(2 * 3 * 4, dtype=np.int8).reshape(2, 3, 4)
| >>> x.transpose(1, 0, 2).view(np.int16)
| array([[[ 256, 770],
| [3340, 3854]],
| <BLANKLINE>
| [[1284, 1798],
| [4368, 4882]],
| <BLANKLINE>
| [[2312, 2826],
| [5396, 5910]]], dtype=int16)
|
| ----------------------------------------------------------------------
| Class methods inherited from ndarray:
|
| __class_getitem__(...) from builtins.type
| a.__class_getitem__(item, /)
|
| Return a parametrized wrapper around the `~numpy.ndarray` type.
|
| .. versionadded:: 1.22
|
| Returns
| -------
| alias : types.GenericAlias
| A parametrized `~numpy.ndarray` type.
|
| Examples
| --------
| >>> from typing import Any
| >>> import numpy as np
|
| >>> np.ndarray[Any, np.dtype[Any]]
| numpy.ndarray[typing.Any, numpy.dtype[typing.Any]]
|
| See Also
| --------
| :pep:`585` : Type hinting generics in standard collections.
| numpy.typing.NDArray : An ndarray alias :term:`generic <generic type>`
| w.r.t. its `dtype.type <numpy.dtype.type>`.
|
| ----------------------------------------------------------------------
| 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.
|
| .. warning::
|
| Setting ``arr.dtype`` is discouraged and may be deprecated in the
| future. Setting will replace the ``dtype`` without modifying the
| memory (see also `ndarray.view` and `ndarray.astype`).
|
| Parameters
| ----------
| None
|
| Returns
| -------
| d : numpy dtype object
|
| See Also
| --------
| ndarray.astype : Cast the values contained in the array to a new data-
type.
| ndarray.view : Create a view of the same data but a different data-
type.
| 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.
| 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, 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:
|
| - 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.
|
| See Also
| --------
| sys.getsizeof
| Memory consumed by the object itself without parents in case view.
| This does include memory consumed by non-element attributes.
|
| 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.
|
| .. warning::
|
| Setting ``arr.shape`` is discouraged and may be deprecated in the
| future. Using `ndarray.reshape` is the preferred approach.
|
| 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.shape : Equivalent getter function.
| numpy.reshape : Function similar to setting ``shape``.
| ndarray.reshape : Method similar to setting ``shape``.
|
| 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.
|
| .. warning::
|
| Setting ``arr.strides`` is discouraged and may be deprecated in the
| future. `numpy.lib.stride_tricks.as_strided` should be preferred
| to create a new view of the same data in a safer way.
|
| 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.
|
| Flush the memmap instance to write the changes to the file. Currently there
| is no API to close the underlying ``mmap``. It is tricky to ensure the
| resource is actually closed, since it may be shared between different
| memmap instances.
|
|
| 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. |
| | | If ``mode == 'w+'`` then `shape` must also be specified. |
| +------+-------------------------------------------------------------+
| | '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.
|
|
| 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
|
| Flushes memory changes to disk in order to read them back
|
| >>> fp.flush()
|
| 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)
| a.__array_finalize__(obj, /)
|
| Present so subclasses can call super. Does nothing.
|
| __array_wrap__(self, arr, context=None)
| a.__array_wrap__(array[, context], /)
|
| Returns a view of `array` with the same type as self.
|
| __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], /)
|
| 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__(array[, context], /)
|
| Returns a view of `array` with the same type as self.
|
| __array_ufunc__(...)
 |
| __bool__(self, /)
| True if self else False
|
| __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, /)
|
| Used if :func:`copy.deepcopy` is called on an array.
|
| __delitem__(self, key, /)
| Delete self[key].
|
| __divmod__(self, value, /)
| Return divmod(self, value).
|
| __dlpack__(...)
| a.__dlpack__(*, stream=None)
|
| DLPack Protocol: Part of the Array API.
|
| __dlpack_device__(...)
| a.__dlpack_device__()
|
| DLPack Protocol: Part of the Array API.
|
| __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, *, where=True)
|
| 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, *, where=True)
|
| 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, *, keepdims=False)
|
| 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, *, keepdims=False)
|
| Return indices of the minimum values along the given axis.
|
| 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, and this function always passes sub-classes through.)
|
| See also
| --------
| numpy.copy : Similar function with different default behavior
| numpy.copyto
|
| Notes
| -----
| This function is the preferred method for creating an array copy. The
| function :func:`numpy.copy` is similar, but it defaults to using order
'K',
| and will not pass sub-classes through by default.
|
| 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(...)
|
| 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 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.])
|
| Fill expects a scalar value and always behaves the same as assigning
| to a single array element. The following is a rare example where this
| distinction is important:
|
| >>> a = np.array([None, None], dtype=object)
| >>> a[0] = np.array(3)
| >>> a
| array([array(3), None], dtype=object)
| >>> a.fill(np.array(3))
| >>> a
| array([array(3), array(3)], dtype=object)
|
| Where other forms of assignments will unpack the array being assigned:
|
| >>> a[...] = np.array(3)
| >>> a
| array([3, 3], dtype=object)
|
| 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, *, where=True)
|
| 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
| * {'<', 'little'} - little endian
| * {'>', 'big'} - big endian
| * {'=', 'native'} - native order, equivalent to `sys.byteorder`
| * {'|', 'I'} - ignore (no change to byte order)
|
| The default value ('S') results in swapping the current
| byte order.
|
|
| 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.
|
| .. deprecated:: 1.22.0
| Passing booleans as index is deprecated.
| 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 partitioned 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,
| 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 flag can never be set
| to True. The flag WRITEABLE can only be set to True if the array owns
its
| own memory, or the ultimate owner of the memory exposes a writeable
buffer
| interface, or is a string. (The exception for string is made so that
| unpickling can be done without copying memory.)
|
| Parameters
| ----------
| write : bool, optional
| Describes whether or not `a` can be written to.
| align : bool, optional
| Describes whether or not `a` is aligned properly for its type.
| uic : bool, optional
| Describes whether or not `a` is a copy of another "base" array.
|
| Notes
| -----
| Array flags provide information about how the memory area used
| for the array is to be interpreted. There are 7 Boolean flags
| in use, only four of which can be changed by the user:
| WRITEBACKIFCOPY, 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);
|
| 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
| >>> y.setflags(write=0, align=0)
| >>> y.flags
| C_CONTIGUOUS : True
| F_CONTIGUOUS : False
| OWNDATA : True
| WRITEABLE : False
| ALIGNED : False
| WRITEBACKIFCOPY : 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 axes of length one from `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, *,
where=True)
|
| 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 is produced in C-order by default.
| This behavior is controlled by the ``order`` parameter.
|
| .. versionadded:: 1.9.0
|
| Parameters
| ----------
| order : {'C', 'F', 'A'}, optional
| Controls the memory layout of the bytes object. 'C' means C-order,
| 'F' means F-order, 'A' (short for *Any*) means 'F' if `a` is
| Fortran contiguous, 'C' otherwise. Default is 'C'.
|
| Returns
| -------
| s : bytes
| Python bytes exhibiting a copy of `a`'s raw data.
|
| See also
| --------
| frombuffer
| Inverse of this operation, construct a 1-dimensional array from
Python
| bytes.
|
| 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.
|
| Refer to `numpy.transpose` for full documentation.
|
| 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 that the
| array's `i`-th axis becomes the transposed array'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
| -------
| p : ndarray
| View of the array with its axes suitably permuted.
|
| See Also
| --------
| transpose : Equivalent function.
| 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]])
|
| >>> a = np.array([1, 2, 3, 4])
| >>> a
| array([1, 2, 3, 4])
| >>> a.transpose()
| array([1, 2, 3, 4])
|
| var(...)
| a.var(axis=None, dtype=None, out=None, ddof=0, keepdims=False, *,
where=True)
|
| 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 last axis of ``a`` must be
| contiguous. This axis will be resized in the result.
|
| .. versionchanged:: 1.23.0
| Only the last axis needs to be contiguous. Previously, the entire
array
| had to be C-contiguous.
|
| 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[:, ::2]
| >>> y
| array([[1, 3],
| [4, 6]], 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 last axis
must be contiguous
| >>> z = y.copy()
| >>> z.view(dtype=[('width', np.int16), ('length', np.int16)])
| array([[(1, 3)],
| [(4, 6)]], dtype=[('width', '<i2'), ('length', '<i2')])
|
| However, views that change dtype are totally fine for arrays with a
| contiguous last axis, even if the rest of the axes are not C-
contiguous:
|
| >>> x = np.arange(2 * 3 * 4, dtype=np.int8).reshape(2, 3, 4)
| >>> x.transpose(1, 0, 2).view(np.int16)
| array([[[ 256, 770],
| [3340, 3854]],
| <BLANKLINE>
| [[1284, 1798],
| [4368, 4882]],
| <BLANKLINE>
| [[2312, 2826],
| [5396, 5910]]], dtype=int16)
|
| ----------------------------------------------------------------------
| Class methods inherited from ndarray:
|
| __class_getitem__(...) from builtins.type
| a.__class_getitem__(item, /)
|
| Return a parametrized wrapper around the `~numpy.ndarray` type.
|
| .. versionadded:: 1.22
|
| Returns
| -------
| alias : types.GenericAlias
| A parametrized `~numpy.ndarray` type.
|
| Examples
| --------
| >>> from typing import Any
| >>> import numpy as np
|
| >>> np.ndarray[Any, np.dtype[Any]]
| numpy.ndarray[typing.Any, numpy.dtype[typing.Any]]
|
| See Also
| --------
| :pep:`585` : Type hinting generics in standard collections.
| numpy.typing.NDArray : An ndarray alias :term:`generic <generic type>`
| w.r.t. its `dtype.type <numpy.dtype.type>`.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from ndarray:
|
| T
| View of the transposed array.
|
| Same as ``self.transpose()``.
|
| Examples
| --------
| >>> a = np.array([[1, 2], [3, 4]])
| >>> a
| array([[1, 2],
| [3, 4]])
| >>> a.T
| array([[1, 3],
| [2, 4]])
|
| >>> a = np.array([1, 2, 3, 4])
| >>> a
| array([1, 2, 3, 4])
| >>> a.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.
|
| .. warning::
|
| Setting ``arr.dtype`` is discouraged and may be deprecated in the
| future. Setting will replace the ``dtype`` without modifying the
| memory (see also `ndarray.view` and `ndarray.astype`).
|
| Parameters
| ----------
| None
|
| Returns
| -------
| d : numpy dtype object
|
| See Also
| --------
| ndarray.astype : Cast the values contained in the array to a new data-
type.
| ndarray.view : Create a view of the same data but a different data-
type.
| 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.
| 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, 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:
|
| - 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.
|
| See Also
| --------
| sys.getsizeof
| Memory consumed by the object itself without parents in case view.
| This does include memory consumed by non-element attributes.
|
| 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.
|
| .. warning::
|
| Setting ``arr.shape`` is discouraged and may be deprecated in the
| future. Using `ndarray.reshape` is the preferred approach.
|
| 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.shape : Equivalent getter function.
| numpy.reshape : Function similar to setting ``shape``.
| ndarray.reshape : Method similar to setting ``shape``.
|
| 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.
|
| .. warning::
|
| Setting ``arr.strides`` is discouraged and may be deprecated in the
| future. `numpy.lib.stride_tricks.as_strided` should be preferred
| to create a new view of the same data in a safer way.
|
| 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.
| numpy.typing.NDArray : An ndarray alias :term:`generic <generic type>`
| w.r.t. its `dtype.type <numpy.dtype.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], /)
|
| 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_finalize__(...)
| a.__array_finalize__(obj, /)
|
| Present so subclasses can call super. Does nothing.
 |
| __array_function__(...)
|
| __array_prepare__(...)
| a.__array_prepare__(array[, context], /)
|
| Returns a view of `array` with the same type as self.
|
| __array_ufunc__(...)
|
| __array_wrap__(...)
| a.__array_wrap__(array[, context], /)
|
| Returns a view of `array` with the same type as self.
|
| __bool__(self, /)
| True if self else False
|
| __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, /)
|
| Used if :func:`copy.deepcopy` is called on an array.
|
| __delitem__(self, key, /)
| Delete self[key].
|
| __divmod__(self, value, /)
| Return divmod(self, value).
|
| __dlpack__(...)
| a.__dlpack__(*, stream=None)
|
| DLPack Protocol: Part of the Array API.
|
| __dlpack_device__(...)
| a.__dlpack_device__()
|
| DLPack Protocol: Part of the Array API.
|
| __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, *, where=True)
|
| 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, *, where=True)
|
| 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, *, keepdims=False)
|
| 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, *, keepdims=False)
|
| Return indices of the minimum values along the given axis.
|
| 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, and this function always passes sub-classes through.)
|
| See also
| --------
| numpy.copy : Similar function with different default behavior
| numpy.copyto
|
| Notes
| -----
| This function is the preferred method for creating an array copy. The
| function :func:`numpy.copy` is similar, but it defaults to using order
'K',
| and will not pass sub-classes through by default.
|
| 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(...)
|
| 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 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.])
|
| Fill expects a scalar value and always behaves the same as assigning
| to a single array element. The following is a rare example where this
| distinction is important:
|
| >>> a = np.array([None, None], dtype=object)
| >>> a[0] = np.array(3)
| >>> a
| array([array(3), None], dtype=object)
| >>> a.fill(np.array(3))
| >>> a
| array([array(3), array(3)], dtype=object)
|
| Where other forms of assignments will unpack the array being assigned:
|
| >>> a[...] = np.array(3)
| >>> a
 | array([3, 3], dtype=object)
|
| 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, *, where=True)
|
| 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
| * {'<', 'little'} - little endian
| * {'>', 'big'} - big endian
| * {'=', 'native'} - native order, equivalent to `sys.byteorder`
| * {'|', 'I'} - ignore (no change to byte order)
|
| The default value ('S') results in swapping the current
| byte order.
|
|
| 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.
|
| .. deprecated:: 1.22.0
| Passing booleans as index is deprecated.
| 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 partitioned 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,
| 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 flag can never be set
| to True. The flag WRITEABLE can only be set to True if the array owns
its
| own memory, or the ultimate owner of the memory exposes a writeable
buffer
| interface, or is a string. (The exception for string is made so that
| unpickling can be done without copying memory.)
|
| Parameters
| ----------
| write : bool, optional
| Describes whether or not `a` can be written to.
| align : bool, optional
| Describes whether or not `a` is aligned properly for its type.
| uic : bool, optional
| Describes whether or not `a` is a copy of another "base" array.
|
| Notes
 | -----
| Array flags provide information about how the memory area used
| for the array is to be interpreted. There are 7 Boolean flags
| in use, only four of which can be changed by the user:
| WRITEBACKIFCOPY, 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);
|
| 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
| >>> y.setflags(write=0, align=0)
| >>> y.flags
| C_CONTIGUOUS : True
| F_CONTIGUOUS : False
| OWNDATA : True
| WRITEABLE : False
| ALIGNED : False
| WRITEBACKIFCOPY : 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 axes of length one from `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, *,
where=True)
|
| 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 is produced in C-order by default.
| This behavior is controlled by the ``order`` parameter.
|
| .. versionadded:: 1.9.0
 |
| Parameters
| ----------
| order : {'C', 'F', 'A'}, optional
| Controls the memory layout of the bytes object. 'C' means C-order,
| 'F' means F-order, 'A' (short for *Any*) means 'F' if `a` is
| Fortran contiguous, 'C' otherwise. Default is 'C'.
|
| Returns
| -------
| s : bytes
| Python bytes exhibiting a copy of `a`'s raw data.
|
| See also
| --------
| frombuffer
| Inverse of this operation, construct a 1-dimensional array from
Python
| bytes.
|
| 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.
|
| Refer to `numpy.transpose` for full documentation.
|
| 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 that the
| array's `i`-th axis becomes the transposed array'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
| -------
| p : ndarray
| View of the array with its axes suitably permuted.
|
| See Also
| --------
| transpose : Equivalent function.
| 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]])
|
| >>> a = np.array([1, 2, 3, 4])
| >>> a
| array([1, 2, 3, 4])
| >>> a.transpose()
| array([1, 2, 3, 4])
|
| var(...)
| a.var(axis=None, dtype=None, out=None, ddof=0, keepdims=False, *,
where=True)
|
| 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 last axis of ``a`` must be
| contiguous. This axis will be resized in the result.
|
| .. versionchanged:: 1.23.0
| Only the last axis needs to be contiguous. Previously, the entire
array
| had to be C-contiguous.
|
| 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[:, ::2]
| >>> y
| array([[1, 3],
| [4, 6]], 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 last axis
must be contiguous
| >>> z = y.copy()
| >>> z.view(dtype=[('width', np.int16), ('length', np.int16)])
| array([[(1, 3)],
| [(4, 6)]], dtype=[('width', '<i2'), ('length', '<i2')])
|
| However, views that change dtype are totally fine for arrays with a
| contiguous last axis, even if the rest of the axes are not C-
contiguous:
|
| >>> x = np.arange(2 * 3 * 4, dtype=np.int8).reshape(2, 3, 4)
| >>> x.transpose(1, 0, 2).view(np.int16)
| array([[[ 256, 770],
| [3340, 3854]],
| <BLANKLINE>
| [[1284, 1798],
| [4368, 4882]],
| <BLANKLINE>
| [[2312, 2826],
| [5396, 5910]]], dtype=int16)
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| __class_getitem__(...) from builtins.type
| a.__class_getitem__(item, /)
|
| Return a parametrized wrapper around the `~numpy.ndarray` type.
|
| .. versionadded:: 1.22
|
| Returns
| -------
| alias : types.GenericAlias
| A parametrized `~numpy.ndarray` type.
|
| Examples
| --------
| >>> from typing import Any
| >>> import numpy as np
|
| >>> np.ndarray[Any, np.dtype[Any]]
| numpy.ndarray[typing.Any, numpy.dtype[typing.Any]]
|
| See Also
| --------
| :pep:`585` : Type hinting generics in standard collections.
| numpy.typing.NDArray : An ndarray alias :term:`generic <generic type>`
| w.r.t. its `dtype.type <numpy.dtype.type>`.
|
| ----------------------------------------------------------------------
| 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
| View of the transposed array.
|
| Same as ``self.transpose()``.
|
| Examples
| --------
| >>> a = np.array([[1, 2], [3, 4]])
| >>> a
| array([[1, 2],
| [3, 4]])
| >>> a.T
| array([[1, 3],
| [2, 4]])
|
| >>> a = np.array([1, 2, 3, 4])
| >>> a
| array([1, 2, 3, 4])
| >>> a.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.
|
| .. warning::
|
| Setting ``arr.dtype`` is discouraged and may be deprecated in the
| future. Setting will replace the ``dtype`` without modifying the
| memory (see also `ndarray.view` and `ndarray.astype`).
|
| Parameters
| ----------
| None
|
| Returns
 | -------
| d : numpy dtype object
|
| See Also
| --------
| ndarray.astype : Cast the values contained in the array to a new data-
type.
| ndarray.view : Create a view of the same data but a different data-
type.
| 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.
| 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, 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:
|
| - 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.
|
| See Also
| --------
| sys.getsizeof
| Memory consumed by the object itself without parents in case view.
| This does include memory consumed by non-element attributes.
|
 | 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.
|
| .. warning::
|
| Setting ``arr.shape`` is discouraged and may be deprecated in the
| future. Using `ndarray.reshape` is the preferred approach.
|
| 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.shape : Equivalent getter function.
| numpy.reshape : Function similar to setting ``shape``.
| ndarray.reshape : Method similar to setting ``shape``.
|
| 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.
|
| .. warning::
|
 | Setting ``arr.strides`` is discouraged and may be deprecated in the
| future. `numpy.lib.stride_tricks.as_strided` should be preferred
| to create a new view of the same data in a safer way.
|
| 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
| ----------
| shape : ints, or a single tuple of ints
| The size of each dimension of the array can be passed as
| individual parameters or as the elements of a tuple.
|
| See Also
| --------
| ndenumerate, flatiter
|
| Examples
| --------
| Dimensions as individual arguments
|
| >>> 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)
|
| Same dimensions - but in a tuple ``(3, 2, 1)``
|
| >>> 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.
|
| .. deprecated:: 1.20.0
 | This method has been advised against since numpy 1.8.0, but only
| started emitting DeprecationWarning as of this version.
|
| ----------------------------------------------------------------------
| 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
|
| Class methods defined here:
|
| __class_getitem__(...) from builtins.type
| __class_getitem__(item, /)
|
| Return a parametrized wrapper around the `~numpy.number` type.
|
| .. versionadded:: 1.22
|
| Returns
| -------
| alias : types.GenericAlias
| A parametrized `~numpy.number` type.
|
| Examples
| --------
| >>> from typing import Any
| >>> import numpy as np
|
| >>> np.signedinteger[Any]
| numpy.signedinteger[typing.Any]
|
| See Also
| --------
| :pep:`585` : Type hinting generics in standard collections.
|
| ----------------------------------------------------------------------
| 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, /)
| True if self else False
|
| __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(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.all`.
|
| any(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.any`.
|
| argmax(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmax`.
|
| argmin(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmin`.
|
| argsort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argsort`.
|
| astype(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.astype`.
|
| byteswap(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.byteswap`.
|
| choose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.choose`.
|
| clip(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.clip`.
|
| compress(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.compress`.
|
| conj(...)
|
| conjugate(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.conjugate`.
|
| copy(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.copy`.
|
| cumprod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumprod`.
|
| cumsum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumsum`.
|
| diagonal(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.diagonal`.
|
| dump(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dump`.
|
| dumps(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dumps`.
|
| fill(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.fill`.
|
| flatten(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.flatten`.
|
| getfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.getfield`.
|
| item(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.item`.
|
| itemset(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.itemset`.
|
| max(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.max`.
|
| mean(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.mean`.
|
| min(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.min`.
|
| newbyteorder(...)
| newbyteorder(new_order='S', /)
|
| Return a new `dtype` with a different byte order.
|
| Changes are also made in all fields and sub-arrays of the data type.
|
| The `new_order` code can be any from the following:
|
| * 'S' - swap dtype from current to opposite endian
| * {'<', 'little'} - little endian
| * {'>', 'big'} - big endian
| * {'=', 'native'} - 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.
|
|
| Returns
| -------
| new_dtype : dtype
| New `dtype` object with the given change to the byte order.
|
| nonzero(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.nonzero`.
|
| prod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.prod`.
|
| ptp(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ptp`.
|
| put(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.put`.
|
| ravel(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ravel`.
|
| repeat(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.repeat`.
|
| reshape(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.reshape`.
|
| resize(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.resize`.
|
| round(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.round`.
|
| searchsorted(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.searchsorted`.
|
| setfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setfield`.
|
| setflags(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setflags`.
|
| sort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sort`.
|
| squeeze(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.squeeze`.
|
| std(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.std`.
|
| sum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sum`.
|
| swapaxes(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.swapaxes`.
|
| take(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.take`.
|
| tobytes(...)
|
| tofile(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tofile`.
|
| tolist(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tolist`.
|
| tostring(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tostring`.
|
| trace(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.trace`.
|
| transpose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.transpose`.
|
| var(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.var`.
|
| view(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.view`.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from generic:
|
| T
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.T`.
|
| __array_interface__
| Array protocol: Python side
|
| __array_priority__
| Array priority.
|
| __array_struct__
| Array protocol: struct
|
| base
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.base`.
|
| data
| Pointer to start of data.
|
| dtype
| Get array data-descriptor.
|
| flags
| The integer value of flags.
|
| flat
| A 1-D view of the scalar.
|
| imag
| The imaginary part of the scalar.
|
| itemsize
| The length of one element in bytes.
|
| nbytes
| The length of the scalar in bytes.
|
| ndim
| The number of array dimensions.
|
| real
| The real part of the scalar.
|
| shape
| Tuple of array dimensions.
|
| size
| The number of elements in the gentype.
|
 | strides
| Tuple of bytes steps in each dimension.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from generic:
|
| __hash__ = None

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, /)
| True if self else False
|
| __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(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.all`.
|
| any(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.any`.
|
| argmax(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmax`.
|
| argmin(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmin`.
|
| argsort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argsort`.
|
| astype(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.astype`.
|
| byteswap(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.byteswap`.
|
| choose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.choose`.
|
| clip(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.clip`.
|
| compress(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.compress`.
|
| conj(...)
|
| conjugate(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.conjugate`.
|
| copy(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.copy`.
|
| cumprod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumprod`.
|
| cumsum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumsum`.
|
| diagonal(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.diagonal`.
|
| dump(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dump`.
|
| dumps(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dumps`.
|
| fill(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.fill`.
|
| flatten(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.flatten`.
|
| getfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.getfield`.
|
| item(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.item`.
|
| itemset(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.itemset`.
|
| max(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.max`.
|
| mean(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.mean`.
|
| min(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.min`.
|
| newbyteorder(...)
| newbyteorder(new_order='S', /)
|
| Return a new `dtype` with a different byte order.
|
| Changes are also made in all fields and sub-arrays of the data type.
|
| The `new_order` code can be any from the following:
|
| * 'S' - swap dtype from current to opposite endian
| * {'<', 'little'} - little endian
| * {'>', 'big'} - big endian
| * {'=', 'native'} - 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.
|
|
| Returns
| -------
| new_dtype : dtype
| New `dtype` object with the given change to the byte order.
|
| nonzero(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.nonzero`.
|
| prod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.prod`.
|
| ptp(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ptp`.
|
| put(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.put`.
|
| ravel(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ravel`.
|
| repeat(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.repeat`.
|
| reshape(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.reshape`.
|
| resize(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.resize`.
|
| round(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.round`.
|
| searchsorted(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.searchsorted`.
|
| setfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setfield`.
|
| setflags(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setflags`.
|
| sort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sort`.
|
| squeeze(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.squeeze`.
|
| std(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.std`.
|
| sum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sum`.
|
| swapaxes(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.swapaxes`.
|
| take(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.take`.
|
| tobytes(...)
|
| tofile(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tofile`.
|
| tolist(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tolist`.
|
| tostring(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tostring`.
|
| trace(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.trace`.
|
| transpose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.transpose`.
|
| var(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.var`.
|
| view(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.view`.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from generic:
|
| T
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.T`.
|
| __array_interface__
| Array protocol: Python side
|
| __array_priority__
| Array priority.
|
| __array_struct__
| Array protocol: struct
|
| base
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.base`.
|
| data
| Pointer to start of data.
|
| dtype
| Get array data-descriptor.
|
| flags
| The integer value of flags.
|
| flat
| A 1-D view of the scalar.
|
| imag
| The imaginary part of the scalar.
|
| itemsize
| The length of one element in bytes.
|
| nbytes
| The length of the scalar in bytes.
|
| ndim
| The number of array dimensions.
|
 | real
| The real part of the scalar.
|
| shape
| Tuple of array dimensions.
|
| size
| The 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.
|
| .. note::
| This forms part of the old polynomial API. Since version 1.4, the
| new polynomial API defined in `numpy.polynomial` is preferred.
| A summary of the differences can be found in the
| :doc:`transition guide </reference/routines.polynomials>`.
|
| 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
| --------
| core.records.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)
| a.__array_finalize__(obj, /)
|
| Present so subclasses can call super. Does nothing.
|
 | __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], /)
|
| 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__(array[, context], /)
|
| Returns a view of `array` with the same type as self.
|
| __array_ufunc__(...)
|
| __array_wrap__(...)
| a.__array_wrap__(array[, context], /)
 |
| Returns a view of `array` with the same type as self.
|
| __bool__(self, /)
| True if self else False
|
| __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, /)
|
| Used if :func:`copy.deepcopy` is called on an array.
|
| __delitem__(self, key, /)
| Delete self[key].
|
| __divmod__(self, value, /)
| Return divmod(self, value).
|
| __dlpack__(...)
| a.__dlpack__(*, stream=None)
|
| DLPack Protocol: Part of the Array API.
|
| __dlpack_device__(...)
| a.__dlpack_device__()
|
| DLPack Protocol: Part of the Array API.
|
| __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, *, where=True)
|
| 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, *, where=True)
|
| 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, *, keepdims=False)
|
| 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, *, keepdims=False)
|
| Return indices of the minimum values along the given axis.
|
| 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, and this function always passes sub-classes through.)
|
| See also
| --------
| numpy.copy : Similar function with different default behavior
| numpy.copyto
|
| Notes
| -----
| This function is the preferred method for creating an array copy. The
| function :func:`numpy.copy` is similar, but it defaults to using order
'K',
| and will not pass sub-classes through by default.
|
| 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(...)
|
| 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 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.])
|
| Fill expects a scalar value and always behaves the same as assigning
| to a single array element. The following is a rare example where this
| distinction is important:
|
| >>> a = np.array([None, None], dtype=object)
| >>> a[0] = np.array(3)
| >>> a
| array([array(3), None], dtype=object)
| >>> a.fill(np.array(3))
| >>> a
| array([array(3), array(3)], dtype=object)
|
| Where other forms of assignments will unpack the array being assigned:
|
| >>> a[...] = np.array(3)
| >>> a
| array([3, 3], dtype=object)
|
| 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, *, where=True)
 |
| 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
| * {'<', 'little'} - little endian
| * {'>', 'big'} - big endian
| * {'=', 'native'} - native order, equivalent to `sys.byteorder`
| * {'|', 'I'} - ignore (no change to byte order)
|
| The default value ('S') results in swapping the current
| byte order.
|
|
| 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.
|
| .. deprecated:: 1.22.0
| Passing booleans as index is deprecated.
| 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 partitioned 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,
| 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 flag can never be set
| to True. The flag WRITEABLE can only be set to True if the array owns
its
| own memory, or the ultimate owner of the memory exposes a writeable
buffer
| interface, or is a string. (The exception for string is made so that
| unpickling can be done without copying memory.)
|
| Parameters
| ----------
| write : bool, optional
| Describes whether or not `a` can be written to.
| align : bool, optional
| Describes whether or not `a` is aligned properly for its type.
| uic : bool, optional
| Describes whether or not `a` is a copy of another "base" array.
|
| Notes
| -----
| Array flags provide information about how the memory area used
| for the array is to be interpreted. There are 7 Boolean flags
| in use, only four of which can be changed by the user:
| WRITEBACKIFCOPY, 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);
|
| 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
| >>> y.setflags(write=0, align=0)
| >>> y.flags
| C_CONTIGUOUS : True
| F_CONTIGUOUS : False
| OWNDATA : True
| WRITEABLE : False
| ALIGNED : False
| WRITEBACKIFCOPY : 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 axes of length one from `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, *,
where=True)
|
| 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 is produced in C-order by default.
| This behavior is controlled by the ``order`` parameter.
|
| .. versionadded:: 1.9.0
|
| Parameters
| ----------
| order : {'C', 'F', 'A'}, optional
| Controls the memory layout of the bytes object. 'C' means C-order,
| 'F' means F-order, 'A' (short for *Any*) means 'F' if `a` is
| Fortran contiguous, 'C' otherwise. Default is 'C'.
|
| Returns
| -------
| s : bytes
| Python bytes exhibiting a copy of `a`'s raw data.
|
| See also
| --------
| frombuffer
| Inverse of this operation, construct a 1-dimensional array from
Python
 | bytes.
|
| 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.
|
| Refer to `numpy.transpose` for full documentation.
|
| 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 that the
| array's `i`-th axis becomes the transposed array'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
| -------
| p : ndarray
| View of the array with its axes suitably permuted.
|
| See Also
| --------
| transpose : Equivalent function.
| 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]])
|
| >>> a = np.array([1, 2, 3, 4])
| >>> a
| array([1, 2, 3, 4])
| >>> a.transpose()
| array([1, 2, 3, 4])
|
| var(...)
| a.var(axis=None, dtype=None, out=None, ddof=0, keepdims=False, *,
where=True)
|
| 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 last axis of ``a`` must be
| contiguous. This axis will be resized in the result.
|
| .. versionchanged:: 1.23.0
| Only the last axis needs to be contiguous. Previously, the entire
array
| had to be C-contiguous.
|
| 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[:, ::2]
| >>> y
| array([[1, 3],
| [4, 6]], 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 last axis
must be contiguous
| >>> z = y.copy()
| >>> z.view(dtype=[('width', np.int16), ('length', np.int16)])
| array([[(1, 3)],
| [(4, 6)]], dtype=[('width', '<i2'), ('length', '<i2')])
|
| However, views that change dtype are totally fine for arrays with a
| contiguous last axis, even if the rest of the axes are not C-
contiguous:
|
| >>> x = np.arange(2 * 3 * 4, dtype=np.int8).reshape(2, 3, 4)
| >>> x.transpose(1, 0, 2).view(np.int16)
| array([[[ 256, 770],
| [3340, 3854]],
| <BLANKLINE>
| [[1284, 1798],
| [4368, 4882]],
| <BLANKLINE>
| [[2312, 2826],
| [5396, 5910]]], dtype=int16)
|
| ----------------------------------------------------------------------
| Class methods inherited from ndarray:
|
| __class_getitem__(...) from builtins.type
| a.__class_getitem__(item, /)
|
| Return a parametrized wrapper around the `~numpy.ndarray` type.
|
| .. versionadded:: 1.22
|
| Returns
| -------
| alias : types.GenericAlias
| A parametrized `~numpy.ndarray` type.
|
| Examples
| --------
| >>> from typing import Any
| >>> import numpy as np
|
| >>> np.ndarray[Any, np.dtype[Any]]
| numpy.ndarray[typing.Any, numpy.dtype[typing.Any]]
|
| See Also
| --------
| :pep:`585` : Type hinting generics in standard collections.
| numpy.typing.NDArray : An ndarray alias :term:`generic <generic type>`
| w.r.t. its `dtype.type <numpy.dtype.type>`.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from ndarray:
|
| T
| View of the transposed array.
|
| Same as ``self.transpose()``.
|
| Examples
| --------
| >>> a = np.array([[1, 2], [3, 4]])
| >>> a
| array([[1, 2],
| [3, 4]])
| >>> a.T
| array([[1, 3],
| [2, 4]])
|
| >>> a = np.array([1, 2, 3, 4])
| >>> a
| array([1, 2, 3, 4])
| >>> a.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.
|
| .. warning::
|
| Setting ``arr.dtype`` is discouraged and may be deprecated in the
| future. Setting will replace the ``dtype`` without modifying the
| memory (see also `ndarray.view` and `ndarray.astype`).
|
| Parameters
| ----------
| None
|
| Returns
| -------
| d : numpy dtype object
|
| See Also
| --------
| ndarray.astype : Cast the values contained in the array to a new data-
type.
| ndarray.view : Create a view of the same data but a different data-
type.
| 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.
| 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, 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:
|
 | - 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.
|
| See Also
| --------
| sys.getsizeof
| Memory consumed by the object itself without parents in case view.
| This does include memory consumed by non-element attributes.
|
| 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.
|
| .. warning::
|
| Setting ``arr.shape`` is discouraged and may be deprecated in the
| future. Using `ndarray.reshape` is the preferred approach.
|
| 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.shape : Equivalent getter function.
| numpy.reshape : Function similar to setting ``shape``.
| ndarray.reshape : Method similar to setting ``shape``.
|
 | 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.
|
| .. warning::
|
| Setting ``arr.strides`` is discouraged and may be deprecated in the
| future. `numpy.lib.stride_tricks.as_strided` should be preferred
| to create a new view of the same data in a safer way.
|
| 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(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.getfield`.
|
| setfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setfield`.
|
| ----------------------------------------------------------------------
| 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, /)
| True if self else False
|
| __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(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.all`.
|
| any(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.any`.
|
| argmax(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmax`.
|
| argmin(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmin`.
|
| argsort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argsort`.
|
| astype(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.astype`.
|
| byteswap(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.byteswap`.
|
| choose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.choose`.
|
| clip(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.clip`.
|
| compress(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.compress`.
|
| conj(...)
|
| conjugate(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.conjugate`.
|
| copy(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.copy`.
|
| cumprod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumprod`.
|
| cumsum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumsum`.
|
| diagonal(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.diagonal`.
|
| dump(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dump`.
|
| dumps(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dumps`.
|
| fill(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.fill`.
|
| flatten(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.flatten`.
|
| item(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.item`.
|
| itemset(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.itemset`.
|
| max(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.max`.
|
| mean(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.mean`.
|
| min(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.min`.
|
| newbyteorder(...)
| newbyteorder(new_order='S', /)
|
| Return a new `dtype` with a different byte order.
|
| Changes are also made in all fields and sub-arrays of the data type.
|
| The `new_order` code can be any from the following:
|
| * 'S' - swap dtype from current to opposite endian
| * {'<', 'little'} - little endian
| * {'>', 'big'} - big endian
| * {'=', 'native'} - 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.
|
|
| Returns
| -------
| new_dtype : dtype
| New `dtype` object with the given change to the byte order.
|
| nonzero(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.nonzero`.
|
| prod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.prod`.
|
| ptp(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ptp`.
|
| put(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.put`.
|
| ravel(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ravel`.
|
| repeat(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.repeat`.
|
| reshape(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.reshape`.
|
| resize(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.resize`.
|
| round(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.round`.
|
| searchsorted(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.searchsorted`.
|
| setflags(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setflags`.
|
| sort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sort`.
|
| squeeze(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.squeeze`.
|
| std(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.std`.
|
| sum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sum`.
|
| swapaxes(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.swapaxes`.
|
| take(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.take`.
|
| tobytes(...)
|
| tofile(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tofile`.
|
| tolist(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tolist`.
|
| tostring(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tostring`.
|
| trace(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.trace`.
|
| transpose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.transpose`.
|
| var(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.var`.
|
| view(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.view`.
|
| ----------------------------------------------------------------------
 | Data descriptors inherited from generic:
|
| T
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.T`.
|
| __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 the scalar.
|
| imag
| The imaginary part of the scalar.
|
| itemsize
| The length of one element in bytes.
|
| nbytes
| The length of the scalar in bytes.
|
| ndim
| The number of array dimensions.
|
| real
| The real part of the scalar.
|
| shape
| Tuple of array dimensions.
|
| size
| The 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: `numpy.short`
| :Alias on this platform (win32 AMD64): `numpy.int16`: 16-bit signed integer
(``-32_768`` to ``32_767``).
|
| 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, /)
| True if self else False
|
| __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.
|
| bit_count(...)
| int16.bit_count() -> int
|
| Computes the number of 1-bits in the absolute value of the input.
| Analogous to the builtin `int.bit_count` or ``popcount`` in C++.
|
| Examples
| --------
| >>> np.int16(127).bit_count()
| 7
| >>> np.int16(-127).bit_count()
| 7
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| __class_getitem__(...) from builtins.type
| __class_getitem__(item, /)
|
| Return a parametrized wrapper around the `~numpy.number` type.
|
| .. versionadded:: 1.22
|
| Returns
| -------
| alias : types.GenericAlias
| A parametrized `~numpy.number` type.
|
| Examples
| --------
| >>> from typing import Any
| >>> import numpy as np
|
| >>> np.signedinteger[Any]
| numpy.signedinteger[typing.Any]
|
| See Also
| --------
| :pep:`585` : Type hinting generics in standard collections.
|
| ----------------------------------------------------------------------
| 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__(...)
|
| is_integer(...)
| integer.is_integer() -> bool
|
| Return ``True`` if the number is finite with integral value.
|
| .. versionadded:: 1.22
|
| Examples
| --------
| >>> np.int64(-2).is_integer()
| True
| >>> np.uint32(5).is_integer()
| True
|
| ----------------------------------------------------------------------
| 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(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.all`.
|
| any(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.any`.
|
| argmax(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmax`.
|
| argmin(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmin`.
|
| argsort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argsort`.
|
| astype(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.astype`.
|
| byteswap(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.byteswap`.
|
| choose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.choose`.
|
| clip(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.clip`.
|
| compress(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.compress`.
|
| conj(...)
|
| conjugate(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.conjugate`.
|
| copy(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.copy`.
|
| cumprod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumprod`.
|
| cumsum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumsum`.
|
| diagonal(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.diagonal`.
|
| dump(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dump`.
|
| dumps(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dumps`.
|
| fill(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.fill`.
|
| flatten(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.flatten`.
|
| getfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.getfield`.
|
| item(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.item`.
|
| itemset(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.itemset`.
|
| max(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.max`.
|
| mean(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.mean`.
|
| min(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.min`.
|
| newbyteorder(...)
| newbyteorder(new_order='S', /)
|
| Return a new `dtype` with a different byte order.
|
| Changes are also made in all fields and sub-arrays of the data type.
|
| The `new_order` code can be any from the following:
|
| * 'S' - swap dtype from current to opposite endian
| * {'<', 'little'} - little endian
| * {'>', 'big'} - big endian
| * {'=', 'native'} - 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.
|
|
| Returns
| -------
| new_dtype : dtype
| New `dtype` object with the given change to the byte order.
|
| nonzero(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.nonzero`.
|
| prod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.prod`.
|
| ptp(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ptp`.
|
| put(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.put`.
|
| ravel(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ravel`.
|
| repeat(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.repeat`.
|
| reshape(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.reshape`.
|
| resize(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.resize`.
|
| round(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.round`.
|
| searchsorted(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.searchsorted`.
|
| setfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setfield`.
|
| setflags(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setflags`.
|
| sort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sort`.
|
| squeeze(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.squeeze`.
|
| std(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.std`.
|
| sum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sum`.
|
| swapaxes(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.swapaxes`.
|
| take(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.take`.
|
| tobytes(...)
|
| tofile(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tofile`.
|
| tolist(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tolist`.
|
| tostring(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tostring`.
|
| trace(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.trace`.
|
| transpose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.transpose`.
|
| var(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.var`.
|
| view(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.view`.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from generic:
|
| T
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.T`.
|
| __array_interface__
| Array protocol: Python side
|
| __array_priority__
| Array priority.
|
| __array_struct__
| Array protocol: struct
|
| base
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.base`.
|
| data
| Pointer to start of data.
|
| dtype
| Get array data-descriptor.
|
| flags
| The integer value of flags.
|
| flat
| A 1-D view of the scalar.
|
| imag
| The imaginary part of the scalar.
|
| itemsize
| The length of one element in bytes.
|
| nbytes
| The length of the scalar in bytes.
|
| ndim
| The number of array dimensions.
|
| real
| The real part of the scalar.
|
| shape
| Tuple of array dimensions.
|
| size
| The 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__(...)
|
| is_integer(...)
| integer.is_integer() -> bool
|
| Return ``True`` if the number is finite with integral value.
|
| .. versionadded:: 1.22
|
| Examples
| --------
| >>> np.int64(-2).is_integer()
| True
| >>> np.uint32(5).is_integer()
| True
|
| ----------------------------------------------------------------------
| Data descriptors inherited from integer:
|
| denominator
| denominator of value (1)
|
| numerator
| numerator of value (the value itself)
|
| ----------------------------------------------------------------------
| Class methods inherited from number:
|
| __class_getitem__(...) from builtins.type
| __class_getitem__(item, /)
|
| Return a parametrized wrapper around the `~numpy.number` type.
|
| .. versionadded:: 1.22
|
| Returns
| -------
| alias : types.GenericAlias
| A parametrized `~numpy.number` type.
|
| Examples
| --------
| >>> from typing import Any
| >>> import numpy as np
|
| >>> np.signedinteger[Any]
| numpy.signedinteger[typing.Any]
|
| See Also
| --------
| :pep:`585` : Type hinting generics in standard collections.
|
| ----------------------------------------------------------------------
| 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, /)
| True if self else False
|
| __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(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.all`.
|
| any(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.any`.
|
| argmax(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmax`.
|
| argmin(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmin`.
|
| argsort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argsort`.
|
| astype(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.astype`.
|
| byteswap(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.byteswap`.
|
| choose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.choose`.
|
| clip(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.clip`.
|
| compress(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.compress`.
|
| conj(...)
|
| conjugate(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.conjugate`.
|
| copy(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.copy`.
|
| cumprod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumprod`.
|
| cumsum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumsum`.
|
| diagonal(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.diagonal`.
|
| dump(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dump`.
|
| dumps(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dumps`.
|
| fill(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.fill`.
|
| flatten(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.flatten`.
|
| getfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.getfield`.
|
| item(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.item`.
|
| itemset(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.itemset`.
|
| max(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.max`.
|
| mean(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.mean`.
|
| min(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.min`.
|
| newbyteorder(...)
| newbyteorder(new_order='S', /)
|
| Return a new `dtype` with a different byte order.
|
| Changes are also made in all fields and sub-arrays of the data type.
|
| The `new_order` code can be any from the following:
|
| * 'S' - swap dtype from current to opposite endian
| * {'<', 'little'} - little endian
| * {'>', 'big'} - big endian
| * {'=', 'native'} - 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.
|
|
| Returns
| -------
| new_dtype : dtype
| New `dtype` object with the given change to the byte order.
|
| nonzero(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.nonzero`.
|
| prod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.prod`.
|
| ptp(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ptp`.
|
| put(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.put`.
|
| ravel(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ravel`.
|
| repeat(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.repeat`.
|
| reshape(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.reshape`.
|
| resize(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.resize`.
|
| round(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.round`.
|
| searchsorted(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.searchsorted`.
|
| setfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setfield`.
|
| setflags(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setflags`.
|
| sort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sort`.
|
| squeeze(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.squeeze`.
|
| std(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.std`.
|
| sum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sum`.
|
| swapaxes(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.swapaxes`.
|
| take(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.take`.
|
| tobytes(...)
|
| tofile(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tofile`.
|
| tolist(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tolist`.
|
| tostring(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tostring`.
|
| trace(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.trace`.
|
| transpose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.transpose`.
|
| var(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.var`.
|
| view(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.view`.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from generic:
|
| T
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.T`.
|
| __array_interface__
| Array protocol: Python side
|
| __array_priority__
| Array priority.
|
| __array_struct__
| Array protocol: struct
|
| base
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.base`.
|
| data
| Pointer to start of data.
|
| dtype
| Get array data-descriptor.
|
| flags
| The integer value of flags.
|
| flat
| A 1-D view of the scalar.
|
| imag
| The imaginary part of the scalar.
|
| itemsize
| The length of one element in bytes.
|
| nbytes
| The length of the scalar in bytes.
|
| ndim
| The number of array dimensions.
|
| real
| The real part of the scalar.
|
| shape
| Tuple of array dimensions.
|
| size
| The 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: `numpy.single`
| :Alias on this platform (win32 AMD64): `numpy.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, /)
| True if self else False
|
| __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)
|
| is_integer(...)
| single.is_integer() -> bool
|
| Return ``True`` if the floating point number is finite with integral
| value, and ``False`` otherwise.
|
| .. versionadded:: 1.22
|
| Examples
| --------
| >>> np.single(-2.0).is_integer()
| True
| >>> np.single(3.2).is_integer()
| False
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| __class_getitem__(...) from builtins.type
| __class_getitem__(item, /)
|
| Return a parametrized wrapper around the `~numpy.number` type.
|
| .. versionadded:: 1.22
|
| Returns
| -------
| alias : types.GenericAlias
| A parametrized `~numpy.number` type.
|
| Examples
| --------
| >>> from typing import Any
| >>> import numpy as np
|
| >>> np.signedinteger[Any]
| numpy.signedinteger[typing.Any]
|
| See Also
| --------
| :pep:`585` : Type hinting generics in standard collections.
|
| ----------------------------------------------------------------------
| 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(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.all`.
|
| any(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.any`.
|
| argmax(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmax`.
|
| argmin(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmin`.
|
| argsort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argsort`.
|
| astype(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.astype`.
|
| byteswap(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.byteswap`.
|
| choose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.choose`.
|
| clip(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.clip`.
|
| compress(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.compress`.
|
| conj(...)
|
| conjugate(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.conjugate`.
|
| copy(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.copy`.
|
| cumprod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumprod`.
|
| cumsum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumsum`.
|
| diagonal(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.diagonal`.
|
| dump(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dump`.
|
| dumps(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dumps`.
|
| fill(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.fill`.
|
| flatten(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.flatten`.
|
| getfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.getfield`.
|
| item(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.item`.
|
| itemset(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.itemset`.
|
| max(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.max`.
|
| mean(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.mean`.
|
| min(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.min`.
|
| newbyteorder(...)
| newbyteorder(new_order='S', /)
|
| Return a new `dtype` with a different byte order.
|
| Changes are also made in all fields and sub-arrays of the data type.
|
| The `new_order` code can be any from the following:
|
| * 'S' - swap dtype from current to opposite endian
| * {'<', 'little'} - little endian
| * {'>', 'big'} - big endian
| * {'=', 'native'} - 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.
|
|
| Returns
| -------
| new_dtype : dtype
| New `dtype` object with the given change to the byte order.
|
| nonzero(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.nonzero`.
|
| prod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.prod`.
|
| ptp(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ptp`.
|
| put(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.put`.
|
| ravel(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ravel`.
|
| repeat(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.repeat`.
|
| reshape(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.reshape`.
|
| resize(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.resize`.
|
| round(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.round`.
|
| searchsorted(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.searchsorted`.
|
| setfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setfield`.
|
| setflags(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setflags`.
|
| sort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sort`.
|
| squeeze(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.squeeze`.
|
| std(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.std`.
|
| sum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sum`.
|
| swapaxes(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.swapaxes`.
|
| take(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.take`.
|
| tobytes(...)
|
| tofile(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tofile`.
|
| tolist(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tolist`.
|
| tostring(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tostring`.
|
| trace(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.trace`.
|
| transpose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.transpose`.
|
| var(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.var`.
|
| view(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.view`.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from generic:
|
| T
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.T`.
|
| __array_interface__
| Array protocol: Python side
|
| __array_priority__
| Array priority.
|
| __array_struct__
| Array protocol: struct
|
| base
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.base`.
|
| data
| Pointer to start of data.
|
| dtype
| Get array data-descriptor.
|
| flags
| The integer value of flags.
|
| flat
| A 1-D view of the scalar.
|
| imag
| The imaginary part of the scalar.
|
| itemsize
| The length of one element in bytes.
|
| nbytes
| The length of the scalar in bytes.
|
| ndim
| The number of array dimensions.
|
| real
| The real part of the scalar.
|
| shape
| Tuple of array dimensions.
|
| size
| The 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: `numpy.csingle`
| :Alias: `numpy.singlecomplex`
| :Alias on this platform (win32 AMD64): `numpy.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, /)
| True if self else False
|
| __complex__(...)
|
| __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.
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| __class_getitem__(...) from builtins.type
| __class_getitem__(item, /)
|
| Return a parametrized wrapper around the `~numpy.number` type.
|
| .. versionadded:: 1.22
|
| Returns
| -------
| alias : types.GenericAlias
| A parametrized `~numpy.number` type.
|
| Examples
| --------
| >>> from typing import Any
| >>> import numpy as np
|
| >>> np.signedinteger[Any]
| numpy.signedinteger[typing.Any]
|
| See Also
| --------
| :pep:`585` : Type hinting generics in standard collections.
|
| ----------------------------------------------------------------------
| 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__(...)
|
| __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(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.all`.
|
| any(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.any`.
|
| argmax(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmax`.
|
| argmin(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmin`.
|
| argsort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argsort`.
|
| astype(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.astype`.
|
| byteswap(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.byteswap`.
|
| choose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.choose`.
|
| clip(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.clip`.
|
| compress(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.compress`.
|
| conj(...)
|
| conjugate(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.conjugate`.
|
| copy(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.copy`.
|
| cumprod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumprod`.
|
| cumsum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumsum`.
|
| diagonal(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.diagonal`.
|
| dump(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dump`.
|
| dumps(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dumps`.
|
| fill(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.fill`.
|
| flatten(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.flatten`.
|
| getfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.getfield`.
|
| item(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.item`.
|
| itemset(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.itemset`.
|
| max(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.max`.
|
| mean(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.mean`.
|
| min(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.min`.
|
| newbyteorder(...)
| newbyteorder(new_order='S', /)
|
| Return a new `dtype` with a different byte order.
|
| Changes are also made in all fields and sub-arrays of the data type.
|
| The `new_order` code can be any from the following:
|
| * 'S' - swap dtype from current to opposite endian
| * {'<', 'little'} - little endian
| * {'>', 'big'} - big endian
| * {'=', 'native'} - 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.
|
|
| Returns
| -------
| new_dtype : dtype
| New `dtype` object with the given change to the byte order.
|
| nonzero(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.nonzero`.
|
| prod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.prod`.
|
| ptp(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ptp`.
|
| put(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.put`.
|
| ravel(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ravel`.
|
| repeat(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.repeat`.
|
| reshape(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.reshape`.
|
| resize(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.resize`.
|
| round(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.round`.
|
| searchsorted(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.searchsorted`.
|
| setfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setfield`.
|
| setflags(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setflags`.
|
| sort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sort`.
|
| squeeze(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.squeeze`.
|
| std(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.std`.
|
| sum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sum`.
|
| swapaxes(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.swapaxes`.
|
| take(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.take`.
|
| tobytes(...)
|
| tofile(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tofile`.
|
| tolist(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tolist`.
|
| tostring(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tostring`.
|
| trace(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.trace`.
|
| transpose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.transpose`.
|
| var(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.var`.
|
| view(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.view`.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from generic:
|
| T
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.T`.
|
| __array_interface__
| Array protocol: Python side
|
| __array_priority__
| Array priority.
|
| __array_struct__
| Array protocol: struct
|
| base
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.base`.
|
| data
| Pointer to start of data.
|
| dtype
| Get array data-descriptor.
|
| flags
| The integer value of flags.
|
| flat
| A 1-D view of the scalar.
|
| imag
| The imaginary part of the scalar.
|
| itemsize
| The length of one element in bytes.
|
 | nbytes
| The length of the scalar in bytes.
|
| ndim
| The number of array dimensions.
|
| real
| The real part of the scalar.
|
| shape
| Tuple of array dimensions.
|
| size
| The number of elements in the gentype.
|
| strides
| Tuple of bytes steps in each dimension.

class str_(builtins.str, character)

| A unicode string.
|
| This type strips trailing null codepoints.
|
| >>> s = np.str_("abc\x00")
| >>> s
| 'abc'
|
| Unlike the builtin `str`, this supports the :ref:`python:bufferobjects`,
exposing its
| contents as UCS4:
|
| >>> m = memoryview(np.str_("abc"))
| >>> m.format
| '3w'
| >>> m.tobytes()
| b'a\x00\x00\x00b\x00\x00\x00c\x00\x00\x00'
|
| :Character code: ``'U'``
| :Alias: `numpy.unicode_`
|
| 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.
|
| removeprefix(self, prefix, /)
| Return a str with the given prefix string removed if present.
|
| If the string starts with the prefix string, return
string[len(prefix):].
| Otherwise, return a copy of the original string.
|
| removesuffix(self, suffix, /)
| Return a str with the given suffix string removed if present.
|
| If the string ends with the suffix string and that suffix is not empty,
| return string[:-len(suffix)]. Otherwise, return a copy of the original
| string.
|
| 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 substrings in the string, using sep as the
separator string.
|
| sep
| The separator used to split the string.
|
| When set to None (the default value), will split on any whitespace
| character (including \\n \\r \\t \\f and spaces) and will discard
| empty strings from the result.
| maxsplit
| Maximum number of splits (starting from the left).
| -1 (the default value) means no limit.
|
| Splitting starts at the end of the string and works 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 substrings in the string, using sep as the
separator string.
|
| sep
| The separator used to split the string.
|
 | When set to None (the default value), will split on any whitespace
| character (including \\n \\r \\t \\f and spaces) and will discard
| empty strings from the result.
| maxsplit
| Maximum number of splits (starting from the left).
| -1 (the default value) means no limit.
|
| Note, str.split() is mainly useful for data that has been intentionally
| delimited. With natural text that includes punctuation, consider using
| the regular expression module.
|
| 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, /)
| True if self else False
|
| __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(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.all`.
|
| any(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.any`.
|
| argmax(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmax`.
|
| argmin(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmin`.
|
| argsort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argsort`.
|
| astype(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.astype`.
|
| byteswap(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.byteswap`.
|
| choose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.choose`.
|
| clip(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.clip`.
|
| compress(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.compress`.
|
| conj(...)
|
| conjugate(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.conjugate`.
|
| copy(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.copy`.
|
| cumprod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumprod`.
|
| cumsum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumsum`.
|
| diagonal(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.diagonal`.
|
| dump(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dump`.
|
| dumps(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dumps`.
|
| fill(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.fill`.
|
| flatten(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.flatten`.
|
| getfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.getfield`.
|
| item(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.item`.
|
| itemset(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.itemset`.
|
| max(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.max`.
|
| mean(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.mean`.
|
| min(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.min`.
|
| newbyteorder(...)
| newbyteorder(new_order='S', /)
|
| Return a new `dtype` with a different byte order.
|
| Changes are also made in all fields and sub-arrays of the data type.
|
| The `new_order` code can be any from the following:
|
| * 'S' - swap dtype from current to opposite endian
| * {'<', 'little'} - little endian
| * {'>', 'big'} - big endian
| * {'=', 'native'} - 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.
|
|
| Returns
| -------
| new_dtype : dtype
| New `dtype` object with the given change to the byte order.
|
| nonzero(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.nonzero`.
|
| prod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.prod`.
|
| ptp(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ptp`.
|
| put(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.put`.
|
| ravel(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ravel`.
|
| repeat(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.repeat`.
|
| reshape(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.reshape`.
|
| resize(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.resize`.
|
| round(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.round`.
|
| searchsorted(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.searchsorted`.
|
| setfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setfield`.
|
| setflags(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setflags`.
|
| sort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sort`.
|
| squeeze(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.squeeze`.
|
| std(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.std`.
|
| sum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sum`.
|
| swapaxes(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.swapaxes`.
|
| take(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.take`.
|
| tobytes(...)
|
| tofile(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tofile`.
|
| tolist(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tolist`.
|
| tostring(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tostring`.
|
| trace(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.trace`.
|
| transpose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.transpose`.
|
| var(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.var`.
|
| view(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.view`.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from generic:
|
| T
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.T`.
|
| __array_interface__
| Array protocol: Python side
|
| __array_priority__
| Array priority.
|
| __array_struct__
| Array protocol: struct
|
| base
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.base`.
|
| data
| Pointer to start of data.
|
| dtype
| Get array data-descriptor.
|
| flags
| The integer value of flags.
|
| flat
| A 1-D view of the scalar.
|
| imag
| The imaginary part of the scalar.
|
| itemsize
| The length of one element in bytes.
|
| nbytes
| The length of the scalar in bytes.
|
| ndim
| The number of array dimensions.
|
| real
| The real part of the scalar.
|
| shape
| Tuple of array dimensions.
|
| size
| The number of elements in the gentype.
|
| strides
| Tuple of bytes steps in each dimension.

string_ = class bytes_(builtins.bytes, character)

| A byte string.
|
| When used in arrays, this type strips trailing null bytes.
|
| :Character code: ``'S'``
| :Alias: `numpy.string_`
|
| 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.
|
| __bytes__(self, /)
| Convert this value to exact type bytes.
|
| __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 string 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.
|
| removeprefix(self, prefix, /)
| Return a bytes object with the given prefix string removed if present.
|
| If the bytes starts with the prefix string, return bytes[len(prefix):].
| Otherwise, return a copy of the original bytes.
|
| removesuffix(self, suffix, /)
| Return a bytes object with the given suffix string removed if present.
|
| If the bytes ends with the suffix string and that suffix is not empty,
| return bytes[:-len(prefix)]. Otherwise, return a copy of the original
| bytes.
|
| 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, /)
| True if self else False
|
| __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(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.all`.
|
| any(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.any`.
|
| argmax(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmax`.
|
| argmin(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmin`.
|
| argsort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argsort`.
|
| astype(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.astype`.
|
| byteswap(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.byteswap`.
|
| choose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.choose`.
|
| clip(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.clip`.
|
| compress(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.compress`.
|
| conj(...)
|
| conjugate(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.conjugate`.
|
| copy(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.copy`.
|
| cumprod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumprod`.
|
| cumsum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumsum`.
|
| diagonal(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.diagonal`.
|
| dump(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dump`.
|
| dumps(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dumps`.
|
| fill(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.fill`.
|
| flatten(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.flatten`.
|
| getfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.getfield`.
|
| item(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.item`.
|
| itemset(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.itemset`.
|
| max(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.max`.
|
| mean(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.mean`.
|
| min(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.min`.
|
| newbyteorder(...)
| newbyteorder(new_order='S', /)
|
| Return a new `dtype` with a different byte order.
|
| Changes are also made in all fields and sub-arrays of the data type.
|
| The `new_order` code can be any from the following:
|
| * 'S' - swap dtype from current to opposite endian
| * {'<', 'little'} - little endian
| * {'>', 'big'} - big endian
| * {'=', 'native'} - 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.
|
|
| Returns
| -------
| new_dtype : dtype
| New `dtype` object with the given change to the byte order.
|
| nonzero(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.nonzero`.
|
| prod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.prod`.
|
| ptp(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ptp`.
|
| put(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.put`.
|
| ravel(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ravel`.
|
| repeat(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.repeat`.
|
| reshape(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.reshape`.
|
| resize(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.resize`.
|
| round(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.round`.
|
| searchsorted(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.searchsorted`.
|
| setfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setfield`.
|
| setflags(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setflags`.
|
| sort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sort`.
|
| squeeze(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.squeeze`.
|
| std(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.std`.
|
| sum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sum`.
|
| swapaxes(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.swapaxes`.
|
| take(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.take`.
|
| tobytes(...)
|
| tofile(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tofile`.
|
| tolist(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tolist`.
|
| tostring(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tostring`.
|
| trace(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.trace`.
|
| transpose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.transpose`.
|
| var(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.var`.
|
| view(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.view`.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from generic:
|
| T
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.T`.
|
| __array_interface__
| Array protocol: Python side
|
| __array_priority__
| Array priority.
|
| __array_struct__
| Array protocol: struct
|
| base
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.base`.
|
| data
| Pointer to start of data.
|
| dtype
| Get array data-descriptor.
|
| flags
| The integer value of flags.
|
| flat
| A 1-D view of the scalar.
|
| imag
| The imaginary part of the scalar.
|
| itemsize
| The length of one element in bytes.
|
| nbytes
| The length of the scalar in bytes.
|
| ndim
| The number of array dimensions.
|
| real
| The real part of the scalar.
|
| shape
| Tuple of array dimensions.
|
| size
| The number of elements in the gentype.
|
| strides
| Tuple of bytes steps in each dimension.

class timedelta64(signedinteger)
| A timedelta stored as a 64-bit integer.
|
| See :ref:`arrays.datetime` for more information.
|
| :Character code: ``'m'``
|
| 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).
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| __class_getitem__(...) from builtins.type
| __class_getitem__(item, /)
|
| Return a parametrized wrapper around the `~numpy.number` type.
|
| .. versionadded:: 1.22
|
| Returns
| -------
| alias : types.GenericAlias
| A parametrized `~numpy.number` type.
|
| Examples
| --------
| >>> from typing import Any
| >>> import numpy as np
|
| >>> np.signedinteger[Any]
| numpy.signedinteger[typing.Any]
|
| See Also
| --------
| :pep:`585` : Type hinting generics in standard collections.
|
| ----------------------------------------------------------------------
| 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__(...)
|
| is_integer(...)
| integer.is_integer() -> bool
|
| Return ``True`` if the number is finite with integral value.
|
| .. versionadded:: 1.22
|
| Examples
| --------
| >>> np.int64(-2).is_integer()
| True
| >>> np.uint32(5).is_integer()
| True
|
| ----------------------------------------------------------------------
| 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, /)
| True if self else False
|
| __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(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.all`.
|
| any(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.any`.
|
| argmax(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmax`.
|
| argmin(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmin`.
|
| argsort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argsort`.
|
| astype(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.astype`.
|
| byteswap(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.byteswap`.
|
| choose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.choose`.
|
| clip(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.clip`.
|
| compress(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.compress`.
|
| conj(...)
|
| conjugate(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.conjugate`.
|
| copy(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.copy`.
|
| cumprod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumprod`.
|
| cumsum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumsum`.
|
| diagonal(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.diagonal`.
|
| dump(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dump`.
|
| dumps(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dumps`.
|
| fill(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.fill`.
|
| flatten(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.flatten`.
|
| getfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.getfield`.
|
| item(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.item`.
|
| itemset(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.itemset`.
|
| max(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.max`.
|
| mean(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.mean`.
|
| min(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.min`.
|
| newbyteorder(...)
| newbyteorder(new_order='S', /)
|
| Return a new `dtype` with a different byte order.
|
| Changes are also made in all fields and sub-arrays of the data type.
|
| The `new_order` code can be any from the following:
|
| * 'S' - swap dtype from current to opposite endian
| * {'<', 'little'} - little endian
| * {'>', 'big'} - big endian
| * {'=', 'native'} - 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.
|
|
| Returns
| -------
| new_dtype : dtype
| New `dtype` object with the given change to the byte order.
|
| nonzero(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.nonzero`.
|
| prod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.prod`.
|
| ptp(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ptp`.
|
| put(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.put`.
|
| ravel(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ravel`.
|
| repeat(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.repeat`.
|
| reshape(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.reshape`.
|
| resize(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.resize`.
|
| round(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.round`.
|
| searchsorted(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.searchsorted`.
|
| setfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setfield`.
|
| setflags(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setflags`.
|
| sort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sort`.
|
| squeeze(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.squeeze`.
|
| std(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.std`.
|
| sum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sum`.
|
| swapaxes(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.swapaxes`.
|
| take(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.take`.
|
| tobytes(...)
|
| tofile(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tofile`.
|
| tolist(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tolist`.
|
| tostring(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tostring`.
|
| trace(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.trace`.
|
| transpose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.transpose`.
|
| var(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.var`.
|
| view(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.view`.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from generic:
|
| T
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.T`.
|
| __array_interface__
| Array protocol: Python side
|
| __array_priority__
| Array priority.
|
| __array_struct__
| Array protocol: struct
|
| base
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.base`.
|
| data
| Pointer to start of data.
|
| dtype
| Get array data-descriptor.
|
| flags
| The integer value of flags.
|
| flat
| A 1-D view of the scalar.
|
| imag
| The imaginary part of the scalar.
|
| itemsize
| The length of one element in bytes.
|
 | nbytes
| The length of the scalar in bytes.
|
| ndim
| The number of array dimensions.
|
| real
| The real part of the scalar.
|
| shape
| Tuple of array dimensions.
|
| size
| The 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: `numpy.ubyte`
| :Alias on this platform (win32 AMD64): `numpy.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, /)
| True if self else False
|
| __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.
|
| bit_count(...)
| uint8.bit_count() -> int
|
| Computes the number of 1-bits in the absolute value of the input.
| Analogous to the builtin `int.bit_count` or ``popcount`` in C++.
|
| Examples
| --------
| >>> np.uint8(127).bit_count()
| 7
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| __class_getitem__(...) from builtins.type
| __class_getitem__(item, /)
|
| Return a parametrized wrapper around the `~numpy.number` type.
|
| .. versionadded:: 1.22
|
| Returns
| -------
| alias : types.GenericAlias
| A parametrized `~numpy.number` type.
|
| Examples
| --------
| >>> from typing import Any
| >>> import numpy as np
|
| >>> np.signedinteger[Any]
| numpy.signedinteger[typing.Any]
|
| See Also
| --------
| :pep:`585` : Type hinting generics in standard collections.
|
| ----------------------------------------------------------------------
| 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__(...)
|
| is_integer(...)
| integer.is_integer() -> bool
|
| Return ``True`` if the number is finite with integral value.
|
| .. versionadded:: 1.22
|
| Examples
| --------
| >>> np.int64(-2).is_integer()
| True
| >>> np.uint32(5).is_integer()
| True
|
| ----------------------------------------------------------------------
| 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(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.all`.
|
| any(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.any`.
|
| argmax(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmax`.
|
| argmin(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmin`.
|
| argsort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argsort`.
|
| astype(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.astype`.
|
| byteswap(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.byteswap`.
|
| choose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.choose`.
|
| clip(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.clip`.
|
| compress(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.compress`.
|
| conj(...)
|
| conjugate(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.conjugate`.
|
| copy(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.copy`.
|
| cumprod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumprod`.
|
| cumsum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumsum`.
|
| diagonal(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.diagonal`.
|
| dump(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dump`.
|
| dumps(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dumps`.
|
| fill(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.fill`.
|
| flatten(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.flatten`.
|
| getfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.getfield`.
|
| item(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.item`.
|
| itemset(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.itemset`.
|
| max(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.max`.
|
| mean(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.mean`.
|
| min(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.min`.
|
| newbyteorder(...)
| newbyteorder(new_order='S', /)
|
| Return a new `dtype` with a different byte order.
|
| Changes are also made in all fields and sub-arrays of the data type.
|
| The `new_order` code can be any from the following:
|
| * 'S' - swap dtype from current to opposite endian
| * {'<', 'little'} - little endian
| * {'>', 'big'} - big endian
| * {'=', 'native'} - 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.
|
|
| Returns
| -------
| new_dtype : dtype
| New `dtype` object with the given change to the byte order.
|
| nonzero(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.nonzero`.
|
| prod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.prod`.
|
| ptp(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ptp`.
|
| put(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.put`.
|
| ravel(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ravel`.
|
| repeat(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.repeat`.
|
| reshape(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.reshape`.
|
| resize(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.resize`.
|
| round(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.round`.
|
| searchsorted(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.searchsorted`.
|
| setfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setfield`.
|
| setflags(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setflags`.
|
| sort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sort`.
|
| squeeze(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.squeeze`.
|
| std(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.std`.
|
| sum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sum`.
|
| swapaxes(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.swapaxes`.
|
| take(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.take`.
|
| tobytes(...)
|
| tofile(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tofile`.
|
| tolist(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tolist`.
|
| tostring(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tostring`.
|
| trace(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.trace`.
|
| transpose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.transpose`.
|
| var(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.var`.
|
| view(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.view`.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from generic:
|
| T
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.T`.
|
| __array_interface__
| Array protocol: Python side
|
| __array_priority__
| Array priority.
|
| __array_struct__
| Array protocol: struct
|
| base
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.base`.
|
| data
| Pointer to start of data.
|
| dtype
| Get array data-descriptor.
|
| flags
| The integer value of flags.
|
| flat
| A 1-D view of the scalar.
|
| imag
| The imaginary part of the scalar.
|
| itemsize
| The length of one element in bytes.
|
| nbytes
| The length of the scalar in bytes.
|
 | ndim
| The number of array dimensions.
|
| real
| The real part of the scalar.
|
| shape
| Tuple of array dimensions.
|
| size
| The 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
| 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`.
| See `ufunc` for a comprehensive overview of all available
arguments.
 |
| 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(array, axis=0, dtype=None, out=None, keepdims=False, initial=<no
value>, where=True)
|
| Reduces `array`'s dimension by one, by applying ufunc along one axis.
|
| Let :math:`array.shape = (N_0, ..., N_i, ..., N_{M-1})`. Then
| :math:`ufunc.reduce(array, 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:`array[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
| ----------
| array : 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 `array`.
|
| .. 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 `array`, 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(array, 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(array[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] = array.shape[axis]``.
| * if ``indices[i] >= indices[i + 1]``, the i-th generalized "row" is
| simply ``array[indices[i]]``.
| * if ``indices[i] >= len(array)`` or ``indices[i] < 0``, an error is
raised.
|
| The shape of the output depends on the size of `indices`, and may be
| larger than `array` (this happens if ``len(indices) >
array.shape[axis]``).
|
| Parameters
| ----------
| array : 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 `array` is 1-D, the function `ufunc.accumulate(array)` is the same
as
 | ``ufunc.reduceat(array, indices)[::2]`` where `indices` is
| ``range(len(array) - 1)`` with a zero placed
| in every other element:
| ``indices = zeros(2 * len(array) - 1)``,
| ``indices[1::2] = range(1, len(array))``.
|
| Don't be fooled by this attribute's name: `reduceat(array)` is not
| necessarily smaller than `array`.
|
| 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.]])
|
| resolve_dtypes(...)
| resolve_dtypes(dtypes, *, signature=None, casting=None,
reduction=False)
|
| Find the dtypes NumPy will use for the operation. Both input and
| output dtypes are returned and may differ from those provided.
|
 | .. note::
|
| This function always applies NEP 50 rules since it is not provided
| any actual values. The Python types ``int``, ``float``, and
| ``complex`` thus behave weak and should be passed for "untyped"
| Python input.
|
| Parameters
| ----------
| dtypes : tuple of dtypes, None, or literal int, float, complex
| The input dtypes for each operand. Output operands can be
| None, indicating that the dtype must be found.
| signature : tuple of DTypes or None, optional
| If given, enforces exact DType (classes) of the specific operand.
| The ufunc ``dtype`` argument is equivalent to passing a tuple with
| only output dtypes set.
| casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
| The casting mode when casting is necessary. This is identical to
| the ufunc call casting modes.
| reduction : boolean
| If given, the resolution assumes a reduce operation is happening
| which slightly changes the promotion and type resolution rules.
| `dtypes` is usually something like ``(None, np.dtype("i2"), None)``
| for reductions (first input is also the output).
|
| .. note::
|
| The default casting mode is "same_kind", however, as of
| NumPy 1.24, NumPy uses "unsafe" for reductions.
|
| Returns
| -------
| dtypes : tuple of dtypes
| The dtypes which NumPy would use for the calculation. Note that
| dtypes may not match the passed in ones (casting is necessary).
|
| See Also
| --------
| numpy.ufunc._resolve_dtypes_and_context :
| Similar function to this, but returns additional information which
| give access to the core C functionality of NumPy.
|
| Examples
| --------
| This API requires passing dtypes, define them for convenience:
|
| >>> int32 = np.dtype("int32")
| >>> float32 = np.dtype("float32")
|
| The typical ufunc call does not pass an output dtype. `np.add` has two
| inputs and one output, so leave the output as ``None`` (not provided):
|
| >>> np.add.resolve_dtypes((int32, float32, None))
| (dtype('float64'), dtype('float64'), dtype('float64'))
|
| The loop found uses "float64" for all operands (including the output),
the
| first input would be cast.
|
 | ``resolve_dtypes`` supports "weak" handling for Python scalars by
passing
| ``int``, ``float``, or ``complex``:
|
| >>> np.add.resolve_dtypes((float32, float, None))
| (dtype('float32'), dtype('float32'), dtype('float32'))
|
| Where the Python ``float`` behaves samilar to a Python value ``0.0``
| in a ufunc call. (See :ref:`NEP 50 <NEP50>` for details.)
|
| ----------------------------------------------------------------------
| 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 uint32(unsignedinteger)

| Unsigned integer type, compatible with C ``unsigned long``.
|
| :Character code: ``'L'``
| :Canonical name: `numpy.uint`
| :Alias on this platform (win32 AMD64): `numpy.uint32`: 32-bit unsigned
integer (``0`` to ``4_294_967_295``).
|
| 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, /)
| True if self else False
|
| __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.
|
| bit_count(...)
| uint32.bit_count() -> int
|
| Computes the number of 1-bits in the absolute value of the input.
| Analogous to the builtin `int.bit_count` or ``popcount`` in C++.
|
| Examples
| --------
| >>> np.uint32(127).bit_count()
| 7
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| __class_getitem__(...) from builtins.type
| __class_getitem__(item, /)
|
| Return a parametrized wrapper around the `~numpy.number` type.
|
| .. versionadded:: 1.22
|
| Returns
| -------
| alias : types.GenericAlias
| A parametrized `~numpy.number` type.
|
| Examples
| --------
| >>> from typing import Any
| >>> import numpy as np
|
| >>> np.signedinteger[Any]
| numpy.signedinteger[typing.Any]
|
| See Also
| --------
| :pep:`585` : Type hinting generics in standard collections.
|
| ----------------------------------------------------------------------
| 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__(...)
|
| is_integer(...)
| integer.is_integer() -> bool
|
| Return ``True`` if the number is finite with integral value.
|
| .. versionadded:: 1.22
|
| Examples
| --------
| >>> np.int64(-2).is_integer()
| True
| >>> np.uint32(5).is_integer()
| True
|
| ----------------------------------------------------------------------
| 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(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.all`.
|
| any(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.any`.
|
| argmax(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmax`.
|
| argmin(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmin`.
|
| argsort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argsort`.
|
| astype(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.astype`.
|
| byteswap(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.byteswap`.
|
| choose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.choose`.
|
| clip(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.clip`.
|
| compress(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.compress`.
|
| conj(...)
|
| conjugate(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.conjugate`.
|
| copy(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.copy`.
|
| cumprod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumprod`.
|
| cumsum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumsum`.
|
| diagonal(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.diagonal`.
|
| dump(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dump`.
|
| dumps(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dumps`.
|
| fill(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.fill`.
|
| flatten(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.flatten`.
|
| getfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.getfield`.
|
| item(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.item`.
|
| itemset(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.itemset`.
|
| max(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.max`.
|
| mean(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.mean`.
|
| min(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.min`.
|
| newbyteorder(...)
| newbyteorder(new_order='S', /)
|
| Return a new `dtype` with a different byte order.
|
| Changes are also made in all fields and sub-arrays of the data type.
|
| The `new_order` code can be any from the following:
|
| * 'S' - swap dtype from current to opposite endian
| * {'<', 'little'} - little endian
| * {'>', 'big'} - big endian
| * {'=', 'native'} - 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.
|
|
| Returns
| -------
| new_dtype : dtype
| New `dtype` object with the given change to the byte order.
|
| nonzero(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.nonzero`.
|
| prod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.prod`.
|
| ptp(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ptp`.
|
| put(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.put`.
|
| ravel(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ravel`.
|
| repeat(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.repeat`.
|
| reshape(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.reshape`.
|
| resize(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.resize`.
|
| round(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.round`.
|
| searchsorted(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.searchsorted`.
|
| setfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setfield`.
|
| setflags(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setflags`.
|
| sort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sort`.
|
| squeeze(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.squeeze`.
|
| std(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.std`.
|
| sum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sum`.
|
| swapaxes(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.swapaxes`.
|
| take(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.take`.
|
| tobytes(...)
|
| tofile(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tofile`.
|
| tolist(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tolist`.
|
| tostring(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tostring`.
|
| trace(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.trace`.
|
| transpose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.transpose`.
|
| var(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.var`.
|
| view(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.view`.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from generic:
|
| T
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.T`.
|
| __array_interface__
| Array protocol: Python side
|
| __array_priority__
| Array priority.
|
| __array_struct__
| Array protocol: struct
|
| base
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.base`.
|
| data
| Pointer to start of data.
|
| dtype
| Get array data-descriptor.
|
| flags
| The integer value of flags.
|
| flat
| A 1-D view of the scalar.
|
| imag
| The imaginary part of the scalar.
|
| itemsize
| The length of one element in bytes.
|
| nbytes
| The length of the scalar in bytes.
|
| ndim
| The number of array dimensions.
|
| real
| The real part of the scalar.
|
| shape
 | Tuple of array dimensions.
|
| size
| The 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: `numpy.ushort`
| :Alias on this platform (win32 AMD64): `numpy.uint16`: 16-bit unsigned
integer (``0`` to ``65_535``).
|
| 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, /)
| True if self else False
|
| __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.
|
| bit_count(...)
| uint16.bit_count() -> int
|
| Computes the number of 1-bits in the absolute value of the input.
| Analogous to the builtin `int.bit_count` or ``popcount`` in C++.
|
| Examples
| --------
| >>> np.uint16(127).bit_count()
| 7
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| __class_getitem__(...) from builtins.type
| __class_getitem__(item, /)
|
| Return a parametrized wrapper around the `~numpy.number` type.
|
| .. versionadded:: 1.22
|
| Returns
| -------
| alias : types.GenericAlias
| A parametrized `~numpy.number` type.
|
| Examples
| --------
| >>> from typing import Any
| >>> import numpy as np
|
| >>> np.signedinteger[Any]
| numpy.signedinteger[typing.Any]
|
| See Also
| --------
| :pep:`585` : Type hinting generics in standard collections.
|
| ----------------------------------------------------------------------
| 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__(...)
|
| is_integer(...)
| integer.is_integer() -> bool
|
| Return ``True`` if the number is finite with integral value.
|
| .. versionadded:: 1.22
|
| Examples
| --------
| >>> np.int64(-2).is_integer()
| True
| >>> np.uint32(5).is_integer()
| True
|
| ----------------------------------------------------------------------
| 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(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.all`.
|
| any(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.any`.
|
| argmax(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmax`.
|
| argmin(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmin`.
|
| argsort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argsort`.
|
| astype(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.astype`.
|
| byteswap(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.byteswap`.
|
| choose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.choose`.
|
| clip(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.clip`.
|
| compress(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.compress`.
|
| conj(...)
|
| conjugate(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.conjugate`.
|
| copy(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.copy`.
|
| cumprod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumprod`.
|
| cumsum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumsum`.
|
| diagonal(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.diagonal`.
|
| dump(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dump`.
|
| dumps(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dumps`.
|
| fill(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.fill`.
|
| flatten(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.flatten`.
|
| getfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.getfield`.
|
| item(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.item`.
|
| itemset(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.itemset`.
|
| max(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.max`.
|
| mean(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.mean`.
|
| min(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.min`.
|
| newbyteorder(...)
| newbyteorder(new_order='S', /)
|
| Return a new `dtype` with a different byte order.
|
| Changes are also made in all fields and sub-arrays of the data type.
|
| The `new_order` code can be any from the following:
|
| * 'S' - swap dtype from current to opposite endian
| * {'<', 'little'} - little endian
| * {'>', 'big'} - big endian
| * {'=', 'native'} - 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.
|
|
| Returns
| -------
| new_dtype : dtype
| New `dtype` object with the given change to the byte order.
|
| nonzero(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.nonzero`.
|
| prod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.prod`.
|
| ptp(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ptp`.
|
| put(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.put`.
|
| ravel(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ravel`.
|
| repeat(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.repeat`.
|
| reshape(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.reshape`.
|
| resize(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.resize`.
|
| round(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.round`.
|
| searchsorted(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.searchsorted`.
|
| setfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setfield`.
|
| setflags(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setflags`.
|
| sort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sort`.
|
| squeeze(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.squeeze`.
|
| std(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.std`.
|
| sum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sum`.
|
| swapaxes(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.swapaxes`.
|
| take(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.take`.
|
| tobytes(...)
|
| tofile(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tofile`.
|
| tolist(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tolist`.
|
| tostring(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tostring`.
|
| trace(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.trace`.
|
| transpose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.transpose`.
|
| var(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.var`.
|
| view(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.view`.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from generic:
|
| T
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.T`.
|
| __array_interface__
| Array protocol: Python side
|
| __array_priority__
| Array priority.
|
| __array_struct__
| Array protocol: struct
|
| base
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.base`.
|
| data
| Pointer to start of data.
|
| dtype
| Get array data-descriptor.
|
| flags
| The integer value of flags.
|
| flat
| A 1-D view of the scalar.
|
| imag
| The imaginary part of the scalar.
|
| itemsize
| The length of one element in bytes.
|
| nbytes
| The length of the scalar in bytes.
|
| ndim
| The number of array dimensions.
|
| real
| The real part of the scalar.
|
| shape
| Tuple of array dimensions.
|
| size
 | The number of elements in the gentype.
|
| strides
| Tuple of bytes steps in each dimension.

class uint32(unsignedinteger)
| Unsigned integer type, compatible with C ``unsigned long``.
|
| :Character code: ``'L'``
| :Canonical name: `numpy.uint`
| :Alias on this platform (win32 AMD64): `numpy.uint32`: 32-bit unsigned
integer (``0`` to ``4_294_967_295``).
|
| 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, /)
| True if self else False
|
| __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.
|
| bit_count(...)
| uint32.bit_count() -> int
|
| Computes the number of 1-bits in the absolute value of the input.
| Analogous to the builtin `int.bit_count` or ``popcount`` in C++.
|
| Examples
| --------
| >>> np.uint32(127).bit_count()
| 7
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| __class_getitem__(...) from builtins.type
| __class_getitem__(item, /)
|
| Return a parametrized wrapper around the `~numpy.number` type.
|
| .. versionadded:: 1.22
|
| Returns
| -------
| alias : types.GenericAlias
| A parametrized `~numpy.number` type.
|
| Examples
| --------
| >>> from typing import Any
| >>> import numpy as np
|
| >>> np.signedinteger[Any]
| numpy.signedinteger[typing.Any]
|
| See Also
| --------
| :pep:`585` : Type hinting generics in standard collections.
|
| ----------------------------------------------------------------------
| 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__(...)
|
| is_integer(...)
| integer.is_integer() -> bool
|
| Return ``True`` if the number is finite with integral value.
|
| .. versionadded:: 1.22
|
| Examples
| --------
| >>> np.int64(-2).is_integer()
| True
| >>> np.uint32(5).is_integer()
| True
|
| ----------------------------------------------------------------------
| 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(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.all`.
|
| any(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.any`.
|
| argmax(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmax`.
|
| argmin(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmin`.
|
| argsort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argsort`.
|
| astype(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.astype`.
|
| byteswap(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.byteswap`.
|
| choose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.choose`.
|
| clip(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.clip`.
|
| compress(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.compress`.
|
| conj(...)
|
| conjugate(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.conjugate`.
|
| copy(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.copy`.
|
| cumprod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumprod`.
|
| cumsum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumsum`.
|
| diagonal(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.diagonal`.
|
| dump(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dump`.
|
| dumps(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dumps`.
|
| fill(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.fill`.
|
| flatten(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.flatten`.
|
| getfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.getfield`.
|
| item(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.item`.
|
| itemset(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.itemset`.
|
| max(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.max`.
|
| mean(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.mean`.
|
| min(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.min`.
|
| newbyteorder(...)
| newbyteorder(new_order='S', /)
|
| Return a new `dtype` with a different byte order.
|
| Changes are also made in all fields and sub-arrays of the data type.
|
| The `new_order` code can be any from the following:
|
| * 'S' - swap dtype from current to opposite endian
| * {'<', 'little'} - little endian
| * {'>', 'big'} - big endian
| * {'=', 'native'} - 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.
|
|
| Returns
| -------
| new_dtype : dtype
| New `dtype` object with the given change to the byte order.
|
| nonzero(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.nonzero`.
|
| prod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.prod`.
|
| ptp(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ptp`.
|
| put(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.put`.
|
| ravel(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ravel`.
|
| repeat(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.repeat`.
|
| reshape(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.reshape`.
|
| resize(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.resize`.
|
| round(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.round`.
|
| searchsorted(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.searchsorted`.
|
| setfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setfield`.
|
| setflags(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setflags`.
|
| sort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sort`.
|
| squeeze(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.squeeze`.
|
| std(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.std`.
|
| sum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sum`.
|
| swapaxes(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.swapaxes`.
|
| take(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.take`.
|
| tobytes(...)
|
| tofile(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tofile`.
|
| tolist(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tolist`.
|
| tostring(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tostring`.
|
| trace(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.trace`.
|
| transpose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.transpose`.
|
| var(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.var`.
|
| view(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.view`.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from generic:
|
| T
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.T`.
|
| __array_interface__
| Array protocol: Python side
|
| __array_priority__
| Array priority.
|
| __array_struct__
| Array protocol: struct
|
| base
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.base`.
|
| data
| Pointer to start of data.
|
| dtype
| Get array data-descriptor.
|
| flags
| The integer value of flags.
|
| flat
| A 1-D view of the scalar.
|
| imag
| The imaginary part of the scalar.
|
| itemsize
| The length of one element in bytes.
|
| nbytes
| The length of the scalar in bytes.
|
| ndim
| The number of array dimensions.
|
| real
| The real part of the scalar.
|
| shape
| Tuple of array dimensions.
|
| size
| The number of elements in the gentype.
|
| strides
 | Tuple of bytes steps in each dimension.

class uint64(unsignedinteger)
| Signed integer type, compatible with C ``unsigned long long``.
|
| :Character code: ``'Q'``
| :Canonical name: `numpy.ulonglong`
| :Alias on this platform (win32 AMD64): `numpy.uint64`: 64-bit unsigned
integer (``0`` to ``18_446_744_073_709_551_615``).
| :Alias on this platform (win32 AMD64): `numpy.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, /)
| True if self else False
|
| __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.
|
| bit_count(...)
| uint64.bit_count() -> int
|
| Computes the number of 1-bits in the absolute value of the input.
| Analogous to the builtin `int.bit_count` or ``popcount`` in C++.
|
| Examples
| --------
| >>> np.uint64(127).bit_count()
| 7
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| __class_getitem__(...) from builtins.type
| __class_getitem__(item, /)
|
| Return a parametrized wrapper around the `~numpy.number` type.
|
| .. versionadded:: 1.22
|
| Returns
| -------
| alias : types.GenericAlias
| A parametrized `~numpy.number` type.
|
| Examples
| --------
| >>> from typing import Any
| >>> import numpy as np
|
| >>> np.signedinteger[Any]
| numpy.signedinteger[typing.Any]
|
| See Also
| --------
| :pep:`585` : Type hinting generics in standard collections.
|
| ----------------------------------------------------------------------
| 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__(...)
|
| is_integer(...)
| integer.is_integer() -> bool
|
| Return ``True`` if the number is finite with integral value.
|
| .. versionadded:: 1.22
|
| Examples
| --------
| >>> np.int64(-2).is_integer()
| True
| >>> np.uint32(5).is_integer()
| True
|
| ----------------------------------------------------------------------
| 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(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.all`.
|
| any(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.any`.
|
| argmax(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmax`.
|
| argmin(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmin`.
|
| argsort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argsort`.
|
| astype(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.astype`.
|
| byteswap(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.byteswap`.
|
| choose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.choose`.
|
| clip(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.clip`.
|
| compress(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.compress`.
|
| conj(...)
|
| conjugate(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.conjugate`.
|
| copy(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.copy`.
|
| cumprod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumprod`.
|
| cumsum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumsum`.
|
| diagonal(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.diagonal`.
|
| dump(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dump`.
|
| dumps(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dumps`.
|
| fill(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.fill`.
|
| flatten(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.flatten`.
|
| getfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.getfield`.
|
| item(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.item`.
|
| itemset(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.itemset`.
|
| max(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.max`.
|
| mean(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.mean`.
|
| min(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.min`.
|
| newbyteorder(...)
| newbyteorder(new_order='S', /)
|
| Return a new `dtype` with a different byte order.
|
| Changes are also made in all fields and sub-arrays of the data type.
|
| The `new_order` code can be any from the following:
|
| * 'S' - swap dtype from current to opposite endian
| * {'<', 'little'} - little endian
| * {'>', 'big'} - big endian
| * {'=', 'native'} - 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.
|
|
| Returns
| -------
| new_dtype : dtype
| New `dtype` object with the given change to the byte order.
|
| nonzero(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.nonzero`.
|
| prod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.prod`.
|
| ptp(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ptp`.
|
| put(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.put`.
|
| ravel(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ravel`.
|
| repeat(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.repeat`.
|
| reshape(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.reshape`.
|
| resize(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.resize`.
|
| round(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.round`.
|
| searchsorted(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.searchsorted`.
|
| setfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setfield`.
|
| setflags(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setflags`.
|
| sort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sort`.
|
| squeeze(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.squeeze`.
|
| std(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.std`.
|
| sum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sum`.
|
| swapaxes(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.swapaxes`.
|
| take(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.take`.
|
| tobytes(...)
|
| tofile(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tofile`.
|
| tolist(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tolist`.
|
| tostring(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tostring`.
|
| trace(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.trace`.
|
| transpose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.transpose`.
|
| var(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.var`.
|
| view(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.view`.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from generic:
|
| T
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.T`.
|
| __array_interface__
| Array protocol: Python side
|
| __array_priority__
| Array priority.
|
| __array_struct__
| Array protocol: struct
|
| base
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.base`.
|
| data
| Pointer to start of data.
|
| dtype
| Get array data-descriptor.
|
| flags
| The integer value of flags.
|
| flat
| A 1-D view of the scalar.
|
| imag
| The imaginary part of the scalar.
|
| itemsize
| The length of one element in bytes.
|
| nbytes
| The length of the scalar in bytes.
|
| ndim
| The number of array dimensions.
|
| real
| The real part of the scalar.
|
| shape
| Tuple of array dimensions.
|
| size
| The 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: `numpy.ubyte`
| :Alias on this platform (win32 AMD64): `numpy.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, /)
| True if self else False
|
| __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.
|
| bit_count(...)
| uint8.bit_count() -> int
|
| Computes the number of 1-bits in the absolute value of the input.
| Analogous to the builtin `int.bit_count` or ``popcount`` in C++.
|
| Examples
| --------
| >>> np.uint8(127).bit_count()
| 7
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| __class_getitem__(...) from builtins.type
| __class_getitem__(item, /)
|
| Return a parametrized wrapper around the `~numpy.number` type.
|
| .. versionadded:: 1.22
|
| Returns
| -------
| alias : types.GenericAlias
| A parametrized `~numpy.number` type.
|
| Examples
| --------
| >>> from typing import Any
| >>> import numpy as np
|
| >>> np.signedinteger[Any]
| numpy.signedinteger[typing.Any]
|
| See Also
| --------
| :pep:`585` : Type hinting generics in standard collections.
|
| ----------------------------------------------------------------------
| 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__(...)
|
| is_integer(...)
| integer.is_integer() -> bool
|
| Return ``True`` if the number is finite with integral value.
|
| .. versionadded:: 1.22
|
| Examples
| --------
| >>> np.int64(-2).is_integer()
| True
| >>> np.uint32(5).is_integer()
| True
|
| ----------------------------------------------------------------------
| 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(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.all`.
|
| any(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.any`.
|
| argmax(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmax`.
|
| argmin(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmin`.
|
| argsort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argsort`.
|
| astype(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.astype`.
|
| byteswap(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.byteswap`.
|
| choose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.choose`.
|
| clip(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.clip`.
|
| compress(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.compress`.
|
| conj(...)
|
| conjugate(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.conjugate`.
|
| copy(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.copy`.
|
| cumprod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumprod`.
|
| cumsum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumsum`.
|
| diagonal(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.diagonal`.
|
| dump(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dump`.
|
| dumps(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dumps`.
|
| fill(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.fill`.
|
| flatten(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.flatten`.
|
| getfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.getfield`.
|
| item(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.item`.
|
| itemset(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.itemset`.
|
| max(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.max`.
|
| mean(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.mean`.
|
| min(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.min`.
|
| newbyteorder(...)
| newbyteorder(new_order='S', /)
|
| Return a new `dtype` with a different byte order.
|
| Changes are also made in all fields and sub-arrays of the data type.
|
| The `new_order` code can be any from the following:
|
| * 'S' - swap dtype from current to opposite endian
| * {'<', 'little'} - little endian
| * {'>', 'big'} - big endian
| * {'=', 'native'} - 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.
|
|
| Returns
| -------
| new_dtype : dtype
| New `dtype` object with the given change to the byte order.
|
| nonzero(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.nonzero`.
|
| prod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.prod`.
|
| ptp(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ptp`.
|
| put(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.put`.
|
| ravel(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ravel`.
|
| repeat(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.repeat`.
|
| reshape(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.reshape`.
|
| resize(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.resize`.
|
| round(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.round`.
|
| searchsorted(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.searchsorted`.
|
| setfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setfield`.
|
| setflags(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setflags`.
|
| sort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sort`.
|
| squeeze(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.squeeze`.
|
| std(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.std`.
|
| sum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sum`.
|
| swapaxes(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.swapaxes`.
|
| take(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.take`.
|
| tobytes(...)
|
| tofile(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tofile`.
|
| tolist(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tolist`.
|
| tostring(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tostring`.
|
| trace(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.trace`.
|
| transpose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.transpose`.
|
| var(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.var`.
|
| view(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.view`.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from generic:
|
| T
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.T`.
|
| __array_interface__
| Array protocol: Python side
|
| __array_priority__
| Array priority.
|
| __array_struct__
| Array protocol: struct
|
| base
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.base`.
|
| data
| Pointer to start of data.
|
| dtype
| Get array data-descriptor.
|
| flags
| The integer value of flags.
|
| flat
| A 1-D view of the scalar.
|
| imag
| The imaginary part of the scalar.
|
| itemsize
| The length of one element in bytes.
|
| nbytes
| The length of the scalar in bytes.
|
| ndim
| The number of array dimensions.
|
| real
| The real part of the scalar.
|
| shape
| Tuple of array dimensions.
|
| size
| The number of elements in the gentype.
|
| strides
| Tuple of bytes steps in each dimension.

class uintc(unsignedinteger)
| Unsigned integer type, compatible with C ``unsigned int``.
 |
| :Character code: ``'I'``
|
| Method resolution order:
| uintc
| 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, /)
| True if self else False
|
| __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.
|
| bit_count(...)
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| __class_getitem__(...) from builtins.type
| __class_getitem__(item, /)
|
| Return a parametrized wrapper around the `~numpy.number` type.
|
| .. versionadded:: 1.22
|
| Returns
| -------
| alias : types.GenericAlias
| A parametrized `~numpy.number` type.
|
| Examples
| --------
| >>> from typing import Any
| >>> import numpy as np
|
| >>> np.signedinteger[Any]
| numpy.signedinteger[typing.Any]
|
| See Also
| --------
| :pep:`585` : Type hinting generics in standard collections.
|
| ----------------------------------------------------------------------
| 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__(...)
|
| is_integer(...)
| integer.is_integer() -> bool
|
| Return ``True`` if the number is finite with integral value.
|
| .. versionadded:: 1.22
|
| Examples
| --------
| >>> np.int64(-2).is_integer()
| True
| >>> np.uint32(5).is_integer()
| True
|
| ----------------------------------------------------------------------
| 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(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.all`.
|
| any(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.any`.
|
| argmax(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmax`.
|
| argmin(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmin`.
|
| argsort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argsort`.
|
| astype(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.astype`.
|
| byteswap(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.byteswap`.
|
| choose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.choose`.
|
| clip(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.clip`.
|
| compress(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.compress`.
|
| conj(...)
|
| conjugate(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.conjugate`.
|
| copy(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.copy`.
|
| cumprod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumprod`.
|
| cumsum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumsum`.
|
| diagonal(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.diagonal`.
|
| dump(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dump`.
|
| dumps(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dumps`.
|
| fill(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.fill`.
|
| flatten(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.flatten`.
|
| getfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.getfield`.
|
| item(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.item`.
|
| itemset(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.itemset`.
|
| max(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.max`.
|
| mean(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.mean`.
|
| min(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.min`.
|
| newbyteorder(...)
| newbyteorder(new_order='S', /)
|
| Return a new `dtype` with a different byte order.
|
| Changes are also made in all fields and sub-arrays of the data type.
|
| The `new_order` code can be any from the following:
|
| * 'S' - swap dtype from current to opposite endian
| * {'<', 'little'} - little endian
| * {'>', 'big'} - big endian
| * {'=', 'native'} - 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.
|
|
| Returns
| -------
| new_dtype : dtype
| New `dtype` object with the given change to the byte order.
|
| nonzero(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.nonzero`.
|
| prod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.prod`.
|
| ptp(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ptp`.
|
| put(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.put`.
|
| ravel(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ravel`.
|
| repeat(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.repeat`.
|
| reshape(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.reshape`.
|
| resize(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.resize`.
|
| round(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.round`.
|
| searchsorted(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.searchsorted`.
|
| setfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setfield`.
|
| setflags(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setflags`.
|
| sort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sort`.
|
| squeeze(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.squeeze`.
|
| std(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.std`.
|
| sum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sum`.
|
| swapaxes(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.swapaxes`.
|
| take(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.take`.
|
| tobytes(...)
|
| tofile(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tofile`.
|
| tolist(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tolist`.
|
| tostring(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tostring`.
|
| trace(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.trace`.
|
| transpose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.transpose`.
|
| var(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.var`.
|
| view(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.view`.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from generic:
|
| T
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.T`.
|
| __array_interface__
| Array protocol: Python side
|
| __array_priority__
| Array priority.
|
| __array_struct__
| Array protocol: struct
 |
| base
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.base`.
|
| data
| Pointer to start of data.
|
| dtype
| Get array data-descriptor.
|
| flags
| The integer value of flags.
|
| flat
| A 1-D view of the scalar.
|
| imag
| The imaginary part of the scalar.
|
| itemsize
| The length of one element in bytes.
|
| nbytes
| The length of the scalar in bytes.
|
| ndim
| The number of array dimensions.
|
| real
| The real part of the scalar.
|
| shape
| Tuple of array dimensions.
|
| size
| The number of elements in the gentype.
|
| strides
| Tuple of bytes steps in each dimension.

uintp = class uint64(unsignedinteger)

| Signed integer type, compatible with C ``unsigned long long``.
|
| :Character code: ``'Q'``
| :Canonical name: `numpy.ulonglong`
| :Alias on this platform (win32 AMD64): `numpy.uint64`: 64-bit unsigned
integer (``0`` to ``18_446_744_073_709_551_615``).
| :Alias on this platform (win32 AMD64): `numpy.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, /)
| True if self else False
|
| __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.
|
| bit_count(...)
| uint64.bit_count() -> int
|
| Computes the number of 1-bits in the absolute value of the input.
| Analogous to the builtin `int.bit_count` or ``popcount`` in C++.
|
| Examples
| --------
| >>> np.uint64(127).bit_count()
| 7
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| __class_getitem__(...) from builtins.type
| __class_getitem__(item, /)
|
| Return a parametrized wrapper around the `~numpy.number` type.
|
| .. versionadded:: 1.22
|
| Returns
| -------
| alias : types.GenericAlias
| A parametrized `~numpy.number` type.
|
| Examples
| --------
| >>> from typing import Any
| >>> import numpy as np
|
| >>> np.signedinteger[Any]
| numpy.signedinteger[typing.Any]
|
| See Also
| --------
| :pep:`585` : Type hinting generics in standard collections.
|
| ----------------------------------------------------------------------
| 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__(...)
|
| is_integer(...)
| integer.is_integer() -> bool
|
| Return ``True`` if the number is finite with integral value.
|
| .. versionadded:: 1.22
|
| Examples
| --------
| >>> np.int64(-2).is_integer()
| True
| >>> np.uint32(5).is_integer()
| True
|
| ----------------------------------------------------------------------
| 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(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.all`.
|
| any(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.any`.
|
| argmax(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmax`.
|
| argmin(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmin`.
|
| argsort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argsort`.
|
| astype(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.astype`.
|
| byteswap(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.byteswap`.
|
| choose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.choose`.
|
| clip(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.clip`.
|
| compress(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.compress`.
|
| conj(...)
|
| conjugate(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.conjugate`.
|
| copy(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.copy`.
|
| cumprod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumprod`.
|
| cumsum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumsum`.
|
| diagonal(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.diagonal`.
|
| dump(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dump`.
|
| dumps(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dumps`.
|
| fill(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.fill`.
|
| flatten(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.flatten`.
|
| getfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.getfield`.
|
| item(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.item`.
|
| itemset(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.itemset`.
|
| max(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.max`.
|
| mean(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.mean`.
|
| min(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.min`.
|
| newbyteorder(...)
| newbyteorder(new_order='S', /)
|
| Return a new `dtype` with a different byte order.
|
| Changes are also made in all fields and sub-arrays of the data type.
|
| The `new_order` code can be any from the following:
|
| * 'S' - swap dtype from current to opposite endian
| * {'<', 'little'} - little endian
| * {'>', 'big'} - big endian
| * {'=', 'native'} - 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.
|
|
| Returns
| -------
| new_dtype : dtype
| New `dtype` object with the given change to the byte order.
|
| nonzero(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.nonzero`.
|
| prod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.prod`.
|
| ptp(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ptp`.
|
| put(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.put`.
|
| ravel(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ravel`.
|
| repeat(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.repeat`.
|
| reshape(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.reshape`.
|
| resize(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.resize`.
|
| round(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.round`.
|
| searchsorted(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.searchsorted`.
|
| setfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setfield`.
|
| setflags(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setflags`.
|
| sort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sort`.
|
| squeeze(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.squeeze`.
|
| std(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.std`.
|
| sum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sum`.
|
| swapaxes(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.swapaxes`.
|
| take(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.take`.
|
| tobytes(...)
|
| tofile(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tofile`.
|
| tolist(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tolist`.
|
| tostring(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tostring`.
|
| trace(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.trace`.
|
| transpose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.transpose`.
|
| var(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.var`.
|
| view(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.view`.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from generic:
|
| T
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.T`.
|
| __array_interface__
| Array protocol: Python side
|
| __array_priority__
| Array priority.
|
| __array_struct__
| Array protocol: struct
|
 | base
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.base`.
|
| data
| Pointer to start of data.
|
| dtype
| Get array data-descriptor.
|
| flags
| The integer value of flags.
|
| flat
| A 1-D view of the scalar.
|
| imag
| The imaginary part of the scalar.
|
| itemsize
| The length of one element in bytes.
|
| nbytes
| The length of the scalar in bytes.
|
| ndim
| The number of array dimensions.
|
| real
| The real part of the scalar.
|
| shape
| Tuple of array dimensions.
|
| size
| The number of elements in the gentype.
|
| strides
| Tuple of bytes steps in each dimension.

ulonglong = class uint64(unsignedinteger)

| Signed integer type, compatible with C ``unsigned long long``.
|
| :Character code: ``'Q'``
| :Canonical name: `numpy.ulonglong`
| :Alias on this platform (win32 AMD64): `numpy.uint64`: 64-bit unsigned
integer (``0`` to ``18_446_744_073_709_551_615``).
| :Alias on this platform (win32 AMD64): `numpy.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, /)
| True if self else False
|
| __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.
|
| bit_count(...)
| uint64.bit_count() -> int
|
| Computes the number of 1-bits in the absolute value of the input.
| Analogous to the builtin `int.bit_count` or ``popcount`` in C++.
|
| Examples
| --------
| >>> np.uint64(127).bit_count()
| 7
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| __class_getitem__(...) from builtins.type
| __class_getitem__(item, /)
|
| Return a parametrized wrapper around the `~numpy.number` type.
|
| .. versionadded:: 1.22
|
| Returns
| -------
| alias : types.GenericAlias
| A parametrized `~numpy.number` type.
|
| Examples
| --------
| >>> from typing import Any
| >>> import numpy as np
|
| >>> np.signedinteger[Any]
| numpy.signedinteger[typing.Any]
|
| See Also
| --------
| :pep:`585` : Type hinting generics in standard collections.
|
| ----------------------------------------------------------------------
| 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__(...)
|
| is_integer(...)
| integer.is_integer() -> bool
|
| Return ``True`` if the number is finite with integral value.
|
| .. versionadded:: 1.22
|
| Examples
| --------
| >>> np.int64(-2).is_integer()
| True
| >>> np.uint32(5).is_integer()
| True
|
| ----------------------------------------------------------------------
| 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(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.all`.
|
| any(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.any`.
|
| argmax(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmax`.
|
| argmin(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmin`.
|
| argsort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argsort`.
|
| astype(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.astype`.
|
| byteswap(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.byteswap`.
|
| choose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.choose`.
|
| clip(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.clip`.
|
| compress(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.compress`.
|
| conj(...)
|
| conjugate(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.conjugate`.
|
| copy(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.copy`.
|
| cumprod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumprod`.
|
| cumsum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumsum`.
|
| diagonal(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.diagonal`.
|
| dump(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dump`.
|
| dumps(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dumps`.
|
| fill(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.fill`.
|
| flatten(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.flatten`.
|
| getfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.getfield`.
|
| item(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.item`.
|
| itemset(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.itemset`.
|
| max(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.max`.
|
| mean(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.mean`.
|
| min(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.min`.
|
| newbyteorder(...)
| newbyteorder(new_order='S', /)
|
| Return a new `dtype` with a different byte order.
|
| Changes are also made in all fields and sub-arrays of the data type.
|
| The `new_order` code can be any from the following:
|
| * 'S' - swap dtype from current to opposite endian
| * {'<', 'little'} - little endian
| * {'>', 'big'} - big endian
| * {'=', 'native'} - 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.
|
|
| Returns
| -------
| new_dtype : dtype
| New `dtype` object with the given change to the byte order.
|
| nonzero(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.nonzero`.
|
| prod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.prod`.
|
| ptp(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ptp`.
|
| put(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.put`.
|
| ravel(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ravel`.
|
| repeat(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.repeat`.
|
| reshape(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.reshape`.
|
| resize(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.resize`.
|
| round(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.round`.
|
| searchsorted(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.searchsorted`.
|
| setfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setfield`.
|
| setflags(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setflags`.
|
| sort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sort`.
|
| squeeze(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.squeeze`.
|
| std(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.std`.
|
| sum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sum`.
|
| swapaxes(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.swapaxes`.
|
| take(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.take`.
|
| tobytes(...)
|
| tofile(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tofile`.
|
| tolist(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tolist`.
|
| tostring(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tostring`.
|
| trace(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.trace`.
|
| transpose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.transpose`.
|
| var(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.var`.
|
| view(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.view`.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from generic:
|
| T
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.T`.
|
| __array_interface__
| Array protocol: Python side
|
| __array_priority__
| Array priority.
|
| __array_struct__
| Array protocol: struct
|
| base
 | Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.base`.
|
| data
| Pointer to start of data.
|
| dtype
| Get array data-descriptor.
|
| flags
| The integer value of flags.
|
| flat
| A 1-D view of the scalar.
|
| imag
| The imaginary part of the scalar.
|
| itemsize
| The length of one element in bytes.
|
| nbytes
| The length of the scalar in bytes.
|
| ndim
| The number of array dimensions.
|
| real
| The real part of the scalar.
|
| shape
| Tuple of array dimensions.
|
| size
| The number of elements in the gentype.
|
| strides
| Tuple of bytes steps in each dimension.

unicode_ = class str_(builtins.str, character)

| A unicode string.
|
| This type strips trailing null codepoints.
|
| >>> s = np.str_("abc\x00")
| >>> s
| 'abc'
|
| Unlike the builtin `str`, this supports the :ref:`python:bufferobjects`,
exposing its
| contents as UCS4:
|
| >>> m = memoryview(np.str_("abc"))
| >>> m.format
| '3w'
| >>> m.tobytes()
| b'a\x00\x00\x00b\x00\x00\x00c\x00\x00\x00'
|
| :Character code: ``'U'``
| :Alias: `numpy.unicode_`
|
| 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.
|
| removeprefix(self, prefix, /)
| Return a str with the given prefix string removed if present.
|
| If the string starts with the prefix string, return
string[len(prefix):].
| Otherwise, return a copy of the original string.
|
| removesuffix(self, suffix, /)
| Return a str with the given suffix string removed if present.
 |
| If the string ends with the suffix string and that suffix is not empty,
| return string[:-len(suffix)]. Otherwise, return a copy of the original
| string.
|
| 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 substrings in the string, using sep as the
separator string.
|
| sep
| The separator used to split the string.
 |
| When set to None (the default value), will split on any whitespace
| character (including \\n \\r \\t \\f and spaces) and will discard
| empty strings from the result.
| maxsplit
| Maximum number of splits (starting from the left).
| -1 (the default value) means no limit.
|
| Splitting starts at the end of the string and works 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 substrings in the string, using sep as the
separator string.
|
| sep
| The separator used to split the string.
|
| When set to None (the default value), will split on any whitespace
| character (including \\n \\r \\t \\f and spaces) and will discard
| empty strings from the result.
| maxsplit
| Maximum number of splits (starting from the left).
| -1 (the default value) means no limit.
|
| Note, str.split() is mainly useful for data that has been intentionally
| delimited. With natural text that includes punctuation, consider using
| the regular expression module.
|
| 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, /)
| True if self else False
|
| __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(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.all`.
|
| any(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.any`.
|
| argmax(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmax`.
|
| argmin(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmin`.
|
| argsort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argsort`.
|
| astype(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.astype`.
|
| byteswap(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.byteswap`.
|
| choose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.choose`.
|
| clip(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.clip`.
|
| compress(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.compress`.
|
| conj(...)
|
| conjugate(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.conjugate`.
|
| copy(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.copy`.
|
| cumprod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumprod`.
|
| cumsum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumsum`.
|
| diagonal(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.diagonal`.
|
| dump(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dump`.
|
| dumps(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dumps`.
|
| fill(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.fill`.
|
| flatten(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.flatten`.
|
| getfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.getfield`.
|
| item(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.item`.
|
| itemset(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.itemset`.
|
| max(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.max`.
|
| mean(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.mean`.
|
| min(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.min`.
|
| newbyteorder(...)
| newbyteorder(new_order='S', /)
|
| Return a new `dtype` with a different byte order.
|
| Changes are also made in all fields and sub-arrays of the data type.
|
| The `new_order` code can be any from the following:
|
| * 'S' - swap dtype from current to opposite endian
| * {'<', 'little'} - little endian
| * {'>', 'big'} - big endian
| * {'=', 'native'} - 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.
|
|
| Returns
| -------
| new_dtype : dtype
| New `dtype` object with the given change to the byte order.
|
| nonzero(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.nonzero`.
|
| prod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.prod`.
|
| ptp(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ptp`.
|
| put(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.put`.
|
| ravel(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ravel`.
|
| repeat(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.repeat`.
|
| reshape(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.reshape`.
|
| resize(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.resize`.
|
| round(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.round`.
|
| searchsorted(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.searchsorted`.
|
| setfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setfield`.
|
| setflags(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setflags`.
|
| sort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sort`.
|
| squeeze(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.squeeze`.
|
| std(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.std`.
|
| sum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sum`.
|
| swapaxes(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.swapaxes`.
|
| take(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.take`.
|
| tobytes(...)
|
| tofile(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tofile`.
|
| tolist(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tolist`.
|
| tostring(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tostring`.
|
| trace(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.trace`.
|
| transpose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.transpose`.
|
| var(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.var`.
|
| view(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.view`.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from generic:
|
| T
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.T`.
|
| __array_interface__
| Array protocol: Python side
|
| __array_priority__
| Array priority.
|
| __array_struct__
| Array protocol: struct
|
| base
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.base`.
|
| data
| Pointer to start of data.
|
| dtype
| Get array data-descriptor.
|
| flags
| The integer value of flags.
|
| flat
| A 1-D view of the scalar.
|
| imag
| The imaginary part of the scalar.
|
| itemsize
| The length of one element in bytes.
|
| nbytes
| The length of the scalar in bytes.
|
| ndim
| The number of array dimensions.
|
| real
| The real part of the scalar.
|
| shape
| Tuple of array dimensions.
|
| size
| The 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__(...)
|
| is_integer(...)
| integer.is_integer() -> bool
|
| Return ``True`` if the number is finite with integral value.
|
| .. versionadded:: 1.22
|
| Examples
| --------
| >>> np.int64(-2).is_integer()
| True
| >>> np.uint32(5).is_integer()
| True
|
| ----------------------------------------------------------------------
| Data descriptors inherited from integer:
|
| denominator
| denominator of value (1)
|
| numerator
| numerator of value (the value itself)
|
| ----------------------------------------------------------------------
| Class methods inherited from number:
|
| __class_getitem__(...) from builtins.type
| __class_getitem__(item, /)
|
| Return a parametrized wrapper around the `~numpy.number` type.
|
| .. versionadded:: 1.22
|
| Returns
| -------
| alias : types.GenericAlias
| A parametrized `~numpy.number` type.
|
| Examples
| --------
| >>> from typing import Any
| >>> import numpy as np
|
| >>> np.signedinteger[Any]
| numpy.signedinteger[typing.Any]
|
| See Also
| --------
| :pep:`585` : Type hinting generics in standard collections.
|
| ----------------------------------------------------------------------
| 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, /)
| True if self else False
|
| __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(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.all`.
|
| any(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.any`.
|
| argmax(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmax`.
|
| argmin(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmin`.
|
| argsort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argsort`.
|
| astype(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.astype`.
|
| byteswap(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.byteswap`.
|
| choose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.choose`.
|
| clip(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.clip`.
|
| compress(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.compress`.
|
| conj(...)
|
| conjugate(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.conjugate`.
|
| copy(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.copy`.
|
| cumprod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumprod`.
|
| cumsum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumsum`.
|
| diagonal(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.diagonal`.
|
| dump(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dump`.
|
| dumps(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dumps`.
|
| fill(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.fill`.
|
| flatten(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.flatten`.
|
| getfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.getfield`.
|
| item(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.item`.
|
| itemset(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.itemset`.
|
| max(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.max`.
|
| mean(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.mean`.
|
| min(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.min`.
|
| newbyteorder(...)
| newbyteorder(new_order='S', /)
|
| Return a new `dtype` with a different byte order.
|
| Changes are also made in all fields and sub-arrays of the data type.
|
| The `new_order` code can be any from the following:
|
| * 'S' - swap dtype from current to opposite endian
| * {'<', 'little'} - little endian
| * {'>', 'big'} - big endian
| * {'=', 'native'} - 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.
|
|
| Returns
| -------
| new_dtype : dtype
| New `dtype` object with the given change to the byte order.
|
| nonzero(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.nonzero`.
|
| prod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.prod`.
|
| ptp(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ptp`.
|
| put(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.put`.
|
| ravel(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ravel`.
|
| repeat(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.repeat`.
|
| reshape(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.reshape`.
|
| resize(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.resize`.
|
| round(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.round`.
|
| searchsorted(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.searchsorted`.
|
| setfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setfield`.
|
| setflags(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setflags`.
|
| sort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sort`.
|
| squeeze(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.squeeze`.
|
| std(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.std`.
|
| sum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sum`.
|
| swapaxes(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.swapaxes`.
|
| take(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.take`.
|
| tobytes(...)
|
| tofile(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tofile`.
|
| tolist(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tolist`.
|
| tostring(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tostring`.
|
| trace(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.trace`.
|
| transpose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.transpose`.
|
| var(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.var`.
|
| view(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.view`.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from generic:
|
| T
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.T`.
|
| __array_interface__
| Array protocol: Python side
|
| __array_priority__
| Array priority.
|
| __array_struct__
| Array protocol: struct
|
| base
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.base`.
|
| data
| Pointer to start of data.
|
| dtype
| Get array data-descriptor.
|
 | flags
| The integer value of flags.
|
| flat
| A 1-D view of the scalar.
|
| imag
| The imaginary part of the scalar.
|
| itemsize
| The length of one element in bytes.
|
| nbytes
| The length of the scalar in bytes.
|
| ndim
| The number of array dimensions.
|
| real
| The real part of the scalar.
|
| shape
| Tuple of array dimensions.
|
| size
| The 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: `numpy.ushort`
| :Alias on this platform (win32 AMD64): `numpy.uint16`: 16-bit unsigned
integer (``0`` to ``65_535``).
|
| 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, /)
| True if self else False
|
| __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.
|
| bit_count(...)
| uint16.bit_count() -> int
|
| Computes the number of 1-bits in the absolute value of the input.
| Analogous to the builtin `int.bit_count` or ``popcount`` in C++.
|
| Examples
| --------
| >>> np.uint16(127).bit_count()
| 7
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| __class_getitem__(...) from builtins.type
| __class_getitem__(item, /)
|
| Return a parametrized wrapper around the `~numpy.number` type.
|
| .. versionadded:: 1.22
|
| Returns
| -------
| alias : types.GenericAlias
| A parametrized `~numpy.number` type.
|
| Examples
| --------
| >>> from typing import Any
| >>> import numpy as np
|
| >>> np.signedinteger[Any]
| numpy.signedinteger[typing.Any]
|
| See Also
| --------
| :pep:`585` : Type hinting generics in standard collections.
|
| ----------------------------------------------------------------------
| 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__(...)
|
| is_integer(...)
| integer.is_integer() -> bool
|
| Return ``True`` if the number is finite with integral value.
|
| .. versionadded:: 1.22
|
| Examples
| --------
| >>> np.int64(-2).is_integer()
| True
| >>> np.uint32(5).is_integer()
| True
|
| ----------------------------------------------------------------------
| 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(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.all`.
|
| any(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.any`.
|
| argmax(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmax`.
|
| argmin(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmin`.
|
| argsort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argsort`.
|
| astype(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.astype`.
|
| byteswap(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.byteswap`.
|
| choose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.choose`.
|
| clip(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.clip`.
|
| compress(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.compress`.
|
| conj(...)
|
| conjugate(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.conjugate`.
|
| copy(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.copy`.
|
| cumprod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumprod`.
|
| cumsum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumsum`.
|
| diagonal(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.diagonal`.
|
| dump(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dump`.
|
| dumps(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dumps`.
|
| fill(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.fill`.
|
| flatten(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.flatten`.
|
| getfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.getfield`.
|
| item(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.item`.
|
| itemset(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.itemset`.
|
| max(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.max`.
|
| mean(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.mean`.
|
| min(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.min`.
|
| newbyteorder(...)
| newbyteorder(new_order='S', /)
|
| Return a new `dtype` with a different byte order.
|
| Changes are also made in all fields and sub-arrays of the data type.
|
| The `new_order` code can be any from the following:
|
| * 'S' - swap dtype from current to opposite endian
| * {'<', 'little'} - little endian
| * {'>', 'big'} - big endian
| * {'=', 'native'} - 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.
|
|
| Returns
| -------
| new_dtype : dtype
| New `dtype` object with the given change to the byte order.
|
| nonzero(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.nonzero`.
|
| prod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.prod`.
|
| ptp(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ptp`.
|
| put(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.put`.
|
| ravel(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ravel`.
|
| repeat(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.repeat`.
|
| reshape(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.reshape`.
|
| resize(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.resize`.
|
| round(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.round`.
|
| searchsorted(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.searchsorted`.
|
| setfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setfield`.
|
| setflags(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setflags`.
|
| sort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sort`.
|
| squeeze(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.squeeze`.
|
| std(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.std`.
|
| sum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sum`.
|
| swapaxes(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.swapaxes`.
|
| take(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.take`.
|
| tobytes(...)
|
| tofile(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tofile`.
|
| tolist(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tolist`.
|
| tostring(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tostring`.
|
| trace(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.trace`.
|
| transpose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.transpose`.
|
| var(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.var`.
|
| view(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.view`.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from generic:
|
| T
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.T`.
|
| __array_interface__
| Array protocol: Python side
|
| __array_priority__
| Array priority.
|
| __array_struct__
| Array protocol: struct
|
| base
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.base`.
|
| data
| Pointer to start of data.
|
| dtype
 | Get array data-descriptor.
|
| flags
| The integer value of flags.
|
| flat
| A 1-D view of the scalar.
|
| imag
| The imaginary part of the scalar.
|
| itemsize
| The length of one element in bytes.
|
| nbytes
| The length of the scalar in bytes.
|
| ndim
| The number of array dimensions.
|
| real
| The real part of the scalar.
|
| shape
| Tuple of array dimensions.
|
| size
| The number of elements in the gentype.
|
| strides
| Tuple of bytes steps in each dimension.

class vectorize(builtins.object)
| vectorize(pyfunc=<no value>, otypes=None, doc=None, excluded=None,
cache=False, signature=None)
|
| vectorize(pyfunc=np._NoValue, otypes=None, doc=None, excluded=None,
| cache=False, signature=None)
|
| Returns an object that acts like pyfunc, but takes arrays as input.
|
| 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, optional
| A python function or method.
| Can be omitted to produce a decorator with keyword arguments.
| 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
| -------
| out : callable
| A vectorized function if ``pyfunc`` was provided,
| a decorator otherwise.
|
| 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] :doc:`/reference/c-api/generalized-ufuncs`
|
| 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.]])
|
| Decorator syntax is supported. The decorator can be called as
| a function to provide keyword arguments.
| >>>@np.vectorize
| ...def identity(x):
| ... return x
| ...
| >>>identity([0, 1, 2])
| array([0, 1, 2])
| >>>@np.vectorize(otypes=[float])
| ...def as_float(x):
| ... return x
| ...
| >>>as_float([0, 1, 2])
| array([0., 1., 2.])
|
| Methods defined here:
|
| __call__(self, *args, **kwargs)
| Call self as a function.
|
| __init__(self, pyfunc=<no value>, 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)
| np.void(length_or_data, /, dtype=None)
|
| Create a new structured or unstructured void scalar.
|
| Parameters
| ----------
| length_or_data : int, array-like, bytes-like, object
| One of multiple meanings (see notes). The length or
| bytes data of an unstructured void. Or alternatively,
| the data to be stored in the new scalar when `dtype`
| is provided.
| This can be an array-like, in which case an array may
| be returned.
| dtype : dtype, optional
| If provided the dtype of the new scalar. This dtype must
| be "void" dtype (i.e. a structured or unstructured void,
| see also :ref:`defining-structured-types`).
|
| ..versionadded:: 1.24
|
| Notes
| -----
| For historical reasons and because void scalars can represent both
| arbitrary byte data and structured dtypes, the void constructor
| has three calling conventions:
|
| 1. ``np.void(5)`` creates a ``dtype="V5"`` scalar filled with five
| ``\0`` bytes. The 5 can be a Python or NumPy integer.
| 2. ``np.void(b"bytes-like")`` creates a void scalar from the byte string.
| The dtype itemsize will match the byte string length, here ``"V10"``.
| 3. When a ``dtype=`` is passed the call is roughly the same as an
| array creation. However, a void scalar rather than array is returned.
|
| Please see the examples which show all three different conventions.
|
| Examples
| --------
| >>> np.void(5)
| void(b'\x00\x00\x00\x00\x00')
| >>> np.void(b'abcd')
| void(b'\x61\x62\x63\x64')
| >>> np.void((5, 3.2, "eggs"), dtype="i,d,S5")
| (5, 3.2, b'eggs') # looks like a tuple, but is `np.void`
| >>> np.void(3, dtype=[('x', np.int8), ('y', np.int8)])
| (3, 3) # looks like a tuple, but is `np.void`
|
| :Character code: ``'V'``
|
| 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(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.getfield`.
|
| setfield(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setfield`.
|
| ----------------------------------------------------------------------
| 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, /)
| True if self else False
|
| __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(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.all`.
|
| any(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.any`.
|
| argmax(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmax`.
|
| argmin(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argmin`.
|
| argsort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.argsort`.
|
| astype(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.astype`.
|
| byteswap(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.byteswap`.
|
| choose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.choose`.
|
| clip(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.clip`.
|
| compress(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.compress`.
|
| conj(...)
|
| conjugate(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.conjugate`.
|
| copy(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.copy`.
|
| cumprod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumprod`.
|
| cumsum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.cumsum`.
|
| diagonal(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.diagonal`.
|
| dump(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dump`.
|
| dumps(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.dumps`.
|
| fill(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.fill`.
|
| flatten(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.flatten`.
|
| item(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.item`.
|
| itemset(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.itemset`.
|
| max(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.max`.
|
| mean(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.mean`.
|
| min(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.min`.
|
| newbyteorder(...)
| newbyteorder(new_order='S', /)
|
| Return a new `dtype` with a different byte order.
|
| Changes are also made in all fields and sub-arrays of the data type.
|
| The `new_order` code can be any from the following:
|
| * 'S' - swap dtype from current to opposite endian
| * {'<', 'little'} - little endian
| * {'>', 'big'} - big endian
| * {'=', 'native'} - 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.
|
|
| Returns
| -------
| new_dtype : dtype
| New `dtype` object with the given change to the byte order.
|
| nonzero(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.nonzero`.
|
| prod(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.prod`.
|
| ptp(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ptp`.
|
| put(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.put`.
|
| ravel(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.ravel`.
|
| repeat(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.repeat`.
|
| reshape(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.reshape`.
|
| resize(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.resize`.
|
| round(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.round`.
|
| searchsorted(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.searchsorted`.
|
| setflags(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.setflags`.
|
| sort(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sort`.
|
| squeeze(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.squeeze`.
|
| std(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.std`.
|
| sum(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.sum`.
|
| swapaxes(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.swapaxes`.
|
| take(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.take`.
|
| tobytes(...)
|
| tofile(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tofile`.
|
| tolist(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tolist`.
|
| tostring(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.tostring`.
|
| trace(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.trace`.
|
| transpose(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.transpose`.
|
| var(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.var`.
|
| view(...)
| Scalar method identical to the corresponding array attribute.
|
| Please see `ndarray.view`.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from generic:
|
| T
| Scalar attribute identical to the corresponding array attribute.
|
| Please see `ndarray.T`.
|
| __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 the scalar.
|
| imag
| The imaginary part of the scalar.
|
| itemsize
| The length of one element in bytes.
 |
| nbytes
| The length of the scalar in bytes.
|
| ndim
| The number of array dimensions.
|
| real
| The real part of the scalar.
|
| shape
| Tuple of array dimensions.
|
| size
| The number of elements in the gentype.
|
| strides
| Tuple of bytes steps in each dimension.

FUNCTIONS
__dir__()

__getattr__(attr)

_add_newdoc_ufunc(...)
add_ufunc_docstring(ufunc, new_docstring)

Replace the docstring for a ufunc with new_docstring.

This method will only work if the current docstring for
the ufunc is NULL. (At the C level, i.e. when ufunc->doc is NULL.)

Parameters
----------
ufunc : numpy.ufunc
A ufunc whose current doc is NULL.
new_docstring : string
The new docstring for the ufunc.

Notes
-----
This method allocates memory for new_docstring on
the heap. Technically this creates a mempory leak, since this
memory will not be reclaimed until the end of the program
even if the ufunc itself is removed. However this will only
be a problem if the user is repeatedly creating ufuncs with
no documentation, adding documentation via add_newdoc_ufunc,
and then throwing away the ufunc.

_get_promotion_state(...)
Get the current NEP 50 promotion state.

_no_nep50_warning()
Context manager to disable NEP 50 warnings. This context manager is
only relevant if the NEP 50 warnings are enabled globally (which is not
thread/context safe).

This warning context manager itself is fully safe, however.

_set_promotion_state(...)
 Set the NEP 50 promotion state. This is not thread-safe.
The optional warnings can be safely silenced using the
`np._no_nep50_warning()` context manager.

_using_numpy2_behavior(...)

add_docstring(...)
add_docstring(obj, docstring)

Add a docstring to a built-in obj if possible.

If the obj already has a docstring raise a RuntimeError
If this routine does not know how to add a docstring to the object
raise a TypeError

add_newdoc(place, obj, doc, warn_on_python=True)

Add documentation to an existing object, typically one defined in C

The purpose is to allow easier editing of the docstrings without requiring

a re-compile. This exists primarily for internal use within numpy itself.

Parameters
----------
place : str
The absolute name of the module to import from
obj : str
The name of the object to add documentation to, typically a class or
function name
doc : {str, Tuple[str, str], List[Tuple[str, str]]}
If a string, the documentation to apply to `obj`

If a tuple, then the first element is interpreted as an attribute of

`obj` and the second as the docstring to apply - ``(method,
docstring)``

If a list, then each element of the list should be a tuple of length

two - ``[(method1, docstring1), (method2, docstring2), ...]``
warn_on_python : bool
If True, the default, emit `UserWarning` if this is used to attach
documentation to a pure-python object.

Notes
-----
This routine never raises an error if the docstring can't be written, but
will raise an error if the object being documented does not exist.

This routine cannot modify read-only docstrings, as appear

in new-style classes or built-in functions. Because this
routine never raises an error the caller must check manually
that the docstrings were changed.

Since this function grabs the ``char *`` from a c-level str object and puts
it into the ``tp_doc`` slot of the type of `obj`, it violates a number of
C-API best-practices, by:

- modifying a `PyTypeObject` after calling `PyType_Ready`

- calling `Py_INCREF` on the str and losing the reference, so the str
will never be released

If possible it should be avoided.

 add_newdoc_ufunc = _add_newdoc_ufunc(...)
add_ufunc_docstring(ufunc, new_docstring)

Replace the docstring for a ufunc with new_docstring.

This method will only work if the current docstring for
the ufunc is NULL. (At the C level, i.e. when ufunc->doc is NULL.)

Parameters
----------
ufunc : numpy.ufunc
A ufunc whose current doc is NULL.
new_docstring : string
The new docstring for the ufunc.

Notes
-----
This method allocates memory for new_docstring on
the heap. Technically this creates a mempory leak, since this
memory will not be reclaimed until the end of the program
even if the ufunc itself is removed. However this will only
be a problem if the user is repeatedly creating ufuncs with
no documentation, adding documentation via add_newdoc_ufunc,
and then throwing away the ufunc.

all(a, axis=None, out=None, keepdims=<no value>, *, where=<no value>)

Test whether all array elements along a given axis evaluate to True.

Parameters
----------
a : array_like
Input array or object that can be converted to an array.
axis : None or int or tuple of ints, optional
Axis or axes along which a logical AND reduction is performed.
The default (``axis=None``) is to perform a logical AND over all
the dimensions of the input array. `axis` may be negative, in
which case it counts from the last to the first axis.

.. versionadded:: 1.7.0

If this is a tuple of ints, a reduction is performed on multiple

axes, instead of a single axis or all the axes as before.
out : ndarray, optional
Alternate output array in which to place the result.
It must have the same shape as the expected output and its
type is preserved (e.g., if ``dtype(out)`` is float, the result
will consist of 0.0's and 1.0's). See :ref:`ufuncs-output-type` for
more
details.

keepdims : bool, optional

If this is set to True, the axes which are reduced are left
in the result as dimensions with size one. With this option,
the result will broadcast correctly against the input array.

If the default value is passed, then `keepdims` will not be

passed through to the `all` method of sub-classes of
`ndarray`, however any non-default value will be. If the
sub-class' method does not implement `keepdims` any
 exceptions will be raised.

where : array_like of bool, optional

Elements to include in checking for all `True` values.
See `~numpy.ufunc.reduce` for details.

.. versionadded:: 1.20.0

Returns
-------
all : ndarray, bool
A new boolean or array is returned unless `out` is specified,
in which case a reference to `out` is returned.

See Also
--------
ndarray.all : equivalent method

any : Test whether any element along a given axis evaluates to True.

Notes
-----
Not a Number (NaN), positive infinity and negative infinity
evaluate to `True` because these are not equal to zero.

Examples
--------
>>> np.all([[True,False],[True,True]])
False

>>> np.all([[True,False],[True,True]], axis=0)

array([ True, False])

>>> np.all([-1, 4, 5])

True

>>> np.all([1.0, np.nan])

True

>>> np.all([[True, True], [False, True]], where=[[True], [False]])

True

>>> o=np.array(False)
>>> z=np.all([-1, 4, 5], out=o)
>>> id(z), id(o), z
(28293632, 28293632, array(True)) # may vary

allclose(a, b, rtol=1e-05, atol=1e-08, equal_nan=False)

Returns True if two arrays are element-wise equal within a tolerance.

The tolerance values are positive, typically very small numbers. The
relative difference (`rtol` * abs(`b`)) and the absolute difference
`atol` are added together to compare against the absolute difference
between `a` and `b`.

NaNs are treated as equal if they are in the same place and if
``equal_nan=True``. Infs are treated as equal if they are in the same
place and of the same sign in both arrays.
 Parameters
----------
a, b : array_like
Input arrays to compare.
rtol : float
The relative tolerance parameter (see Notes).
atol : float
The absolute tolerance parameter (see Notes).
equal_nan : bool
Whether to compare NaN's as equal. If True, NaN's in `a` will be
considered equal to NaN's in `b` in the output array.

.. versionadded:: 1.10.0

Returns
-------
allclose : bool
Returns True if the two arrays are equal within the given
tolerance; False otherwise.

See Also
--------
isclose, all, any, equal

Notes
-----
If the following equation is element-wise True, then allclose returns
True.

absolute(`a` - `b`) <= (`atol` + `rtol` * absolute(`b`))

The above equation is not symmetric in `a` and `b`, so that

``allclose(a, b)`` might be different from ``allclose(b, a)`` in
some rare cases.

The comparison of `a` and `b` uses standard broadcasting, which

means that `a` and `b` need not have the same shape in order for
``allclose(a, b)`` to evaluate to True. The same is true for
`equal` but not `array_equal`.

`allclose` is not defined for non-numeric data types.

`bool` is considered a numeric data-type for this purpose.

Examples
--------
>>> np.allclose([1e10,1e-7], [1.00001e10,1e-8])
False
>>> np.allclose([1e10,1e-8], [1.00001e10,1e-9])
True
>>> np.allclose([1e10,1e-8], [1.0001e10,1e-9])
False
>>> np.allclose([1.0, np.nan], [1.0, np.nan])
False
>>> np.allclose([1.0, np.nan], [1.0, np.nan], equal_nan=True)
True

alltrue(*args, **kwargs)
Check if all elements of input array are true.
 .. deprecated:: 1.25.0
``alltrue`` is deprecated as of NumPy 1.25.0, and will be
removed in NumPy 2.0. Please use `all` instead.

See Also
--------
numpy.all : Equivalent function; see for details.

amax(a, axis=None, out=None, keepdims=<no value>, initial=<no value>, where=<no

value>)
Return the maximum of an array or maximum along an axis.

`amax` is an alias of `~numpy.max`.

See Also
--------
max : alias of this function
ndarray.max : equivalent method

amin(a, axis=None, out=None, keepdims=<no value>, initial=<no value>, where=<no

value>)
Return the minimum of an array or minimum along an axis.

`amin` is an alias of `~numpy.min`.

See Also
--------
min : alias of this function
ndarray.min : equivalent method

angle(z, deg=False)
Return the angle of the complex argument.

Parameters
----------
z : array_like
A complex number or sequence of complex numbers.
deg : bool, optional
Return angle in degrees if True, radians if False (default).

Returns
-------
angle : ndarray or scalar
The counterclockwise angle from the positive real axis on the complex
plane in the range ``(-pi, pi]``, with dtype as numpy.float64.

.. versionchanged:: 1.16.0
This function works on subclasses of ndarray like `ma.array`.

See Also
--------
arctan2
absolute

Notes
-----
Although the angle of the complex number 0 is undefined, ``numpy.angle(0)``
returns the value 0.
 Examples
--------
>>> np.angle([1.0, 1.0j, 1+1j]) # in radians
array([ 0. , 1.57079633, 0.78539816]) # may vary
>>> np.angle(1+1j, deg=True) # in degrees
45.0

any(a, axis=None, out=None, keepdims=<no value>, *, where=<no value>)

Test whether any array element along a given axis evaluates to True.

Returns single boolean if `axis` is ``None``

Parameters
----------
a : array_like
Input array or object that can be converted to an array.
axis : None or int or tuple of ints, optional
Axis or axes along which a logical OR reduction is performed.
The default (``axis=None``) is to perform a logical OR over all
the dimensions of the input array. `axis` may be negative, in
which case it counts from the last to the first axis.

.. versionadded:: 1.7.0

If this is a tuple of ints, a reduction is performed on multiple

axes, instead of a single axis or all the axes as before.
out : ndarray, optional
Alternate output array in which to place the result. It must have
the same shape as the expected output and its type is preserved
(e.g., if it is of type float, then it will remain so, returning
1.0 for True and 0.0 for False, regardless of the type of `a`).
See :ref:`ufuncs-output-type` for more details.

keepdims : bool, optional

If this is set to True, the axes which are reduced are left
in the result as dimensions with size one. With this option,
the result will broadcast correctly against the input array.

If the default value is passed, then `keepdims` will not be

passed through to the `any` method of sub-classes of
`ndarray`, however any non-default value will be. If the
sub-class' method does not implement `keepdims` any
exceptions will be raised.

where : array_like of bool, optional

Elements to include in checking for any `True` values.
See `~numpy.ufunc.reduce` for details.

.. versionadded:: 1.20.0

Returns
-------
any : bool or ndarray
A new boolean or `ndarray` is returned unless `out` is specified,
in which case a reference to `out` is returned.

See Also
--------
ndarray.any : equivalent method
 all : Test whether all elements along a given axis evaluate to True.

Notes
-----
Not a Number (NaN), positive infinity and negative infinity evaluate
to `True` because these are not equal to zero.

Examples
--------
>>> np.any([[True, False], [True, True]])
True

>>> np.any([[True, False], [False, False]], axis=0)

array([ True, False])

>>> np.any([-1, 0, 5])

True

>>> np.any(np.nan)
True

>>> np.any([[True, False], [False, False]], where=[[False], [True]])

False

>>> o=np.array(False)
>>> z=np.any([-1, 4, 5], out=o)
>>> z, o
(array(True), array(True))
>>> # Check now that z is a reference to o
>>> z is o
True
>>> id(z), id(o) # identity of z and o # doctest: +SKIP
(191614240, 191614240)

append(arr, values, axis=None)

Append values to the end of an array.

Parameters
----------
arr : array_like
Values are appended to a copy of this array.
values : array_like
These values are appended to a copy of `arr`. It must be of the
correct shape (the same shape as `arr`, excluding `axis`). If
`axis` is not specified, `values` can be any shape and will be
flattened before use.
axis : int, optional
The axis along which `values` are appended. If `axis` is not
given, both `arr` and `values` are flattened before use.

Returns
-------
append : ndarray
A copy of `arr` with `values` appended to `axis`. Note that
`append` does not occur in-place: a new array is allocated and
filled. If `axis` is None, `out` is a flattened array.

See Also
 --------
insert : Insert elements into an array.
delete : Delete elements from an array.

Examples
--------
>>> np.append([1, 2, 3], [[4, 5, 6], [7, 8, 9]])
array([1, 2, 3, ..., 7, 8, 9])

When `axis` is specified, `values` must have the correct shape.

>>> np.append([[1, 2, 3], [4, 5, 6]], [[7, 8, 9]], axis=0)

array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
>>> np.append([[1, 2, 3], [4, 5, 6]], [7, 8, 9], axis=0)
Traceback (most recent call last):
...
ValueError: all the input arrays must have same number of dimensions, but
the array at index 0 has 2 dimension(s) and the array at index 1 has 1
dimension(s)

apply_along_axis(func1d, axis, arr, *args, **kwargs)

Apply a function to 1-D slices along the given axis.

Execute `func1d(a, *args, **kwargs)` where `func1d` operates on 1-D arrays

and `a` is a 1-D slice of `arr` along `axis`.

This is equivalent to (but faster than) the following use of `ndindex` and
`s_`, which sets each of ``ii``, ``jj``, and ``kk`` to a tuple of indices::

Ni, Nk = a.shape[:axis], a.shape[axis+1:]

for ii in ndindex(Ni):
for kk in ndindex(Nk):
f = func1d(arr[ii + s_[:,] + kk])
Nj = f.shape
for jj in ndindex(Nj):
out[ii + jj + kk] = f[jj]

Equivalently, eliminating the inner loop, this can be expressed as::

Ni, Nk = a.shape[:axis], a.shape[axis+1:]

for ii in ndindex(Ni):
for kk in ndindex(Nk):
out[ii + s_[...,] + kk] = func1d(arr[ii + s_[:,] + kk])

Parameters
----------
func1d : function (M,) -> (Nj...)
This function should accept 1-D arrays. It is applied to 1-D
slices of `arr` along the specified axis.
axis : integer
Axis along which `arr` is sliced.
arr : ndarray (Ni..., M, Nk...)
Input array.
args : any
Additional arguments to `func1d`.
kwargs : any
Additional named arguments to `func1d`.
 .. versionadded:: 1.9.0

Returns
-------
out : ndarray (Ni..., Nj..., Nk...)
The output array. The shape of `out` is identical to the shape of
`arr`, except along the `axis` dimension. This axis is removed, and
replaced with new dimensions equal to the shape of the return value
of `func1d`. So if `func1d` returns a scalar `out` will have one
fewer dimensions than `arr`.

See Also
--------
apply_over_axes : Apply a function repeatedly over multiple axes.

Examples
--------
>>> def my_func(a):
... """Average first and last element of a 1-D array"""
... return (a[0] + a[-1]) * 0.5
>>> b = np.array([[1,2,3], [4,5,6], [7,8,9]])
>>> np.apply_along_axis(my_func, 0, b)
array([4., 5., 6.])
>>> np.apply_along_axis(my_func, 1, b)
array([2., 5., 8.])

For a function that returns a 1D array, the number of dimensions in

`outarr` is the same as `arr`.

>>> b = np.array([[8,1,7], [4,3,9], [5,2,6]])

>>> np.apply_along_axis(sorted, 1, b)
array([[1, 7, 8],
[3, 4, 9],
[2, 5, 6]])

For a function that returns a higher dimensional array, those dimensions

are inserted in place of the `axis` dimension.

>>> b = np.array([[1,2,3], [4,5,6], [7,8,9]])

>>> np.apply_along_axis(np.diag, -1, b)
array([[[1, 0, 0],
[0, 2, 0],
[0, 0, 3]],
[[4, 0, 0],
[0, 5, 0],
[0, 0, 6]],
[[7, 0, 0],
[0, 8, 0],
[0, 0, 9]]])

apply_over_axes(func, a, axes)
Apply a function repeatedly over multiple axes.

`func` is called as `res = func(a, axis)`, where `axis` is the first

element of `axes`. The result `res` of the function call must have
either the same dimensions as `a` or one less dimension. If `res`
has one less dimension than `a`, a dimension is inserted before
 `axis`. The call to `func` is then repeated for each axis in `axes`,
with `res` as the first argument.

Parameters
----------
func : function
This function must take two arguments, `func(a, axis)`.
a : array_like
Input array.
axes : array_like
Axes over which `func` is applied; the elements must be integers.

Returns
-------
apply_over_axis : ndarray
The output array. The number of dimensions is the same as `a`,
but the shape can be different. This depends on whether `func`
changes the shape of its output with respect to its input.

See Also
--------
apply_along_axis :
Apply a function to 1-D slices of an array along the given axis.

Notes
-----
This function is equivalent to tuple axis arguments to reorderable ufuncs
with keepdims=True. Tuple axis arguments to ufuncs have been available
since
version 1.7.0.

Examples
--------
>>> a = np.arange(24).reshape(2,3,4)
>>> a
array([[[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]],
[[12, 13, 14, 15],
[16, 17, 18, 19],
[20, 21, 22, 23]]])

Sum over axes 0 and 2. The result has same number of dimensions
as the original array:

>>> np.apply_over_axes(np.sum, a, [0,2])

array([[[ 60],
[ 92],
[124]]])

Tuple axis arguments to ufuncs are equivalent:

>>> np.sum(a, axis=(0,2), keepdims=True)

array([[[ 60],
[ 92],
[124]]])

arange(...)
arange([start,] stop[, step,], dtype=None, *, like=None)
Return evenly spaced values within a given interval.

``arange`` can be called with a varying number of positional arguments:

* ``arange(stop)``: Values are generated within the half-open interval

``[0, stop)`` (in other words, the interval including `start` but
excluding `stop`).
* ``arange(start, stop)``: Values are generated within the half-open
interval ``[start, stop)``.
* ``arange(start, stop, step)`` Values are generated within the half-open
interval ``[start, stop)``, with spacing between values given by
``step``.

For integer arguments the function is roughly equivalent to the Python

built-in :py:class:`range`, but returns an ndarray rather than a ``range``
instance.

When using a non-integer step, such as 0.1, it is often better to use

`numpy.linspace`.

See the Warning sections below for more information.

Parameters
----------
start : integer or real, optional
Start of interval. The interval includes this value. The default
start value is 0.
stop : integer or real
End of interval. The interval does not include this value, except
in some cases where `step` is not an integer and floating point
round-off affects the length of `out`.
step : integer or real, optional
Spacing between values. For any output `out`, this is the distance
between two adjacent values, ``out[i+1] - out[i]``. The default
step size is 1. If `step` is specified as a position argument,
`start` must also be given.
dtype : dtype, optional
The type of the output array. If `dtype` is not given, infer the data
type from the other input arguments.
like : array_like, optional
Reference object to allow the creation of arrays which are not
NumPy arrays. If an array-like passed in as ``like`` supports
the ``__array_function__`` protocol, the result will be defined
by it. In this case, it ensures the creation of an array object
compatible with that passed in via this argument.

.. versionadded:: 1.20.0

Returns
-------
arange : ndarray
Array of evenly spaced values.

For floating point arguments, the length of the result is

``ceil((stop - start)/step)``. Because of floating point overflow,
this rule may result in the last element of `out` being greater
than `stop`.
 Warnings
--------
The length of the output might not be numerically stable.

Another stability issue is due to the internal implementation of

`numpy.arange`.
The actual step value used to populate the array is
``dtype(start + step) - dtype(start)`` and not `step`. Precision loss
can occur here, due to casting or due to using floating points when
`start` is much larger than `step`. This can lead to unexpected
behaviour. For example::

>>> np.arange(0, 5, 0.5, dtype=int)

array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
>>> np.arange(-3, 3, 0.5, dtype=int)
array([-3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8])

In such cases, the use of `numpy.linspace` should be preferred.

The built-in :py:class:`range` generates :std:doc:`Python built-in integers

that have arbitrary size <python:c-api/long>`, while `numpy.arange`
produces `numpy.int32` or `numpy.int64` numbers. This may result in
incorrect results for large integer values::

>>> power = 40
>>> modulo = 10000
>>> x1 = [(n ** power) % modulo for n in range(8)]
>>> x2 = [(n ** power) % modulo for n in np.arange(8)]
>>> print(x1)
[0, 1, 7776, 8801, 6176, 625, 6576, 4001] # correct
>>> print(x2)
[0, 1, 7776, 7185, 0, 5969, 4816, 3361] # incorrect

See Also
--------
numpy.linspace : Evenly spaced numbers with careful handling of endpoints.
numpy.ogrid: Arrays of evenly spaced numbers in N-dimensions.
numpy.mgrid: Grid-shaped arrays of evenly spaced numbers in N-dimensions.
:ref:`how-to-partition`

Examples
--------
>>> np.arange(3)
array([0, 1, 2])
>>> np.arange(3.0)
array([ 0., 1., 2.])
>>> np.arange(3,7)
array([3, 4, 5, 6])
>>> np.arange(3,7,2)
array([3, 5])

argmax(a, axis=None, out=None, *, keepdims=<no value>)

Returns the indices of the maximum values along an axis.

Parameters
----------
a : array_like
Input array.
axis : int, optional
 By default, the index is into the flattened array, otherwise
along the specified axis.
out : array, optional
If provided, the result will be inserted into this array. It should
be of the appropriate shape and dtype.
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 array.

.. versionadded:: 1.22.0

Returns
-------
index_array : ndarray of ints
Array of indices into the array. It has the same shape as `a.shape`
with the dimension along `axis` removed. If `keepdims` is set to True,
then the size of `axis` will be 1 with the resulting array having same
shape as `a.shape`.

See Also
--------
ndarray.argmax, argmin
amax : The maximum value along a given axis.
unravel_index : Convert a flat index into an index tuple.
take_along_axis : Apply ``np.expand_dims(index_array, axis)``
from argmax to an array as if by calling max.

Notes
-----
In case of multiple occurrences of the maximum values, the indices
corresponding to the first occurrence are returned.

Examples
--------
>>> a = np.arange(6).reshape(2,3) + 10
>>> a
array([[10, 11, 12],
[13, 14, 15]])
>>> np.argmax(a)
5
>>> np.argmax(a, axis=0)
array([1, 1, 1])
>>> np.argmax(a, axis=1)
array([2, 2])

Indexes of the maximal elements of a N-dimensional array:

>>> ind = np.unravel_index(np.argmax(a, axis=None), a.shape)

>>> ind
(1, 2)
>>> a[ind]
15

>>> b = np.arange(6)
>>> b[1] = 5
>>> b
array([0, 5, 2, 3, 4, 5])
>>> np.argmax(b) # Only the first occurrence is returned.
 1

>>> x = np.array([[4,2,3], [1,0,3]])

>>> index_array = np.argmax(x, axis=-1)
>>> # Same as np.amax(x, axis=-1, keepdims=True)
>>> np.take_along_axis(x, np.expand_dims(index_array, axis=-1), axis=-1)
array([[4],
[3]])
>>> # Same as np.amax(x, axis=-1)
>>> np.take_along_axis(x, np.expand_dims(index_array, axis=-1), axis=-
1).squeeze(axis=-1)
array([4, 3])

Setting `keepdims` to `True`,

>>> x = np.arange(24).reshape((2, 3, 4))

>>> res = np.argmax(x, axis=1, keepdims=True)
>>> res.shape
(2, 1, 4)

argmin(a, axis=None, out=None, *, keepdims=<no value>)

Returns the indices of the minimum values along an axis.

Parameters
----------
a : array_like
Input array.
axis : int, optional
By default, the index is into the flattened array, otherwise
along the specified axis.
out : array, optional
If provided, the result will be inserted into this array. It should
be of the appropriate shape and dtype.
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 array.

.. versionadded:: 1.22.0

Returns
-------
index_array : ndarray of ints
Array of indices into the array. It has the same shape as `a.shape`
with the dimension along `axis` removed. If `keepdims` is set to True,
then the size of `axis` will be 1 with the resulting array having same
shape as `a.shape`.

See Also
--------
ndarray.argmin, argmax
amin : The minimum value along a given axis.
unravel_index : Convert a flat index into an index tuple.
take_along_axis : Apply ``np.expand_dims(index_array, axis)``
from argmin to an array as if by calling min.

Notes
-----
In case of multiple occurrences of the minimum values, the indices
 corresponding to the first occurrence are returned.

Examples
--------
>>> a = np.arange(6).reshape(2,3) + 10
>>> a
array([[10, 11, 12],
[13, 14, 15]])
>>> np.argmin(a)
0
>>> np.argmin(a, axis=0)
array([0, 0, 0])
>>> np.argmin(a, axis=1)
array([0, 0])

Indices of the minimum elements of a N-dimensional array:

>>> ind = np.unravel_index(np.argmin(a, axis=None), a.shape)

>>> ind
(0, 0)
>>> a[ind]
10

>>> b = np.arange(6) + 10
>>> b[4] = 10
>>> b
array([10, 11, 12, 13, 10, 15])
>>> np.argmin(b) # Only the first occurrence is returned.
0

>>> x = np.array([[4,2,3], [1,0,3]])

>>> index_array = np.argmin(x, axis=-1)
>>> # Same as np.amin(x, axis=-1, keepdims=True)
>>> np.take_along_axis(x, np.expand_dims(index_array, axis=-1), axis=-1)
array([[2],
[0]])
>>> # Same as np.amax(x, axis=-1)
>>> np.take_along_axis(x, np.expand_dims(index_array, axis=-1), axis=-
1).squeeze(axis=-1)
array([2, 0])

Setting `keepdims` to `True`,

>>> x = np.arange(24).reshape((2, 3, 4))

>>> res = np.argmin(x, axis=1, keepdims=True)
>>> res.shape
(2, 1, 4)

argpartition(a, kth, axis=-1, kind='introselect', order=None)

Perform an indirect partition along the given axis using the
algorithm specified by the `kind` keyword. It returns an array of
indices of the same shape as `a` that index data along the given
axis in partitioned order.

.. versionadded:: 1.8.0

Parameters
----------
a : array_like
 Array to sort.
kth : int or sequence of ints
Element index to partition by. The k-th element will be in its
final sorted position and all smaller elements will be moved
before it and all larger elements behind it. The order of all
elements in the partitions is undefined. If provided with a
sequence of k-th it will partition all of them into their sorted
position at once.

.. deprecated:: 1.22.0
Passing booleans as index is deprecated.
axis : int or None, optional
Axis along which to sort. The default is -1 (the last axis). If
None, the flattened array is used.
kind : {'introselect'}, optional
Selection algorithm. Default is 'introselect'
order : str or list of str, optional
When `a` is an array with fields defined, this argument
specifies which fields to compare first, second, etc. A single
field can be specified as a string, and not all fields need be
specified, but unspecified fields will still be used, in the
order in which they come up in the dtype, to break ties.

Returns
-------
index_array : ndarray, int
Array of indices that partition `a` along the specified axis.
If `a` is one-dimensional, ``a[index_array]`` yields a partitioned `a`.
More generally, ``np.take_along_axis(a, index_array, axis=axis)``
always yields the partitioned `a`, irrespective of dimensionality.

See Also
--------
partition : Describes partition algorithms used.
ndarray.partition : Inplace partition.
argsort : Full indirect sort.
take_along_axis : Apply ``index_array`` from argpartition
to an array as if by calling partition.

Notes
-----
See `partition` for notes on the different selection algorithms.

Examples
--------
One dimensional array:

>>> x = np.array([3, 4, 2, 1])

>>> x[np.argpartition(x, 3)]
array([2, 1, 3, 4])
>>> x[np.argpartition(x, (1, 3))]
array([1, 2, 3, 4])

>>> x = [3, 4, 2, 1]
>>> np.array(x)[np.argpartition(x, 3)]
array([2, 1, 3, 4])

Multi-dimensional array:
 >>> x = np.array([[3, 4, 2], [1, 3, 1]])
>>> index_array = np.argpartition(x, kth=1, axis=-1)
>>> np.take_along_axis(x, index_array, axis=-1) # same as np.partition(x,
kth=1)
array([[2, 3, 4],
[1, 1, 3]])

argsort(a, axis=-1, kind=None, order=None)

Returns the indices that would sort an array.

Perform an indirect sort along the given axis using the algorithm specified
by the `kind` keyword. It returns an array of indices of the same shape as
`a` that index data along the given axis in sorted order.

Parameters
----------
a : array_like
Array to sort.
axis : int or None, optional
Axis along which to sort. The default is -1 (the last axis). If None,
the flattened array is used.
kind : {'quicksort', 'mergesort', 'heapsort', '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 data type. 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.

Returns
-------
index_array : ndarray, int
Array of indices that sort `a` along the specified `axis`.
If `a` is one-dimensional, ``a[index_array]`` yields a sorted `a`.
More generally, ``np.take_along_axis(a, index_array, axis=axis)``
always yields the sorted `a`, irrespective of dimensionality.

See Also
--------
sort : Describes sorting algorithms used.
lexsort : Indirect stable sort with multiple keys.
ndarray.sort : Inplace sort.
argpartition : Indirect partial sort.
take_along_axis : Apply ``index_array`` from argsort
to an array as if by calling sort.

Notes
-----
See `sort` for notes on the different sorting algorithms.

As of NumPy 1.4.0 `argsort` works with real/complex arrays containing

nan values. The enhanced sort order is documented in `sort`.
 Examples
--------
One dimensional array:

>>> x = np.array([3, 1, 2])

>>> np.argsort(x)
array([1, 2, 0])

Two-dimensional array:

>>> x = np.array([[0, 3], [2, 2]])

>>> x
array([[0, 3],
[2, 2]])

>>> ind = np.argsort(x, axis=0) # sorts along first axis (down)

>>> ind
array([[0, 1],
[1, 0]])
>>> np.take_along_axis(x, ind, axis=0) # same as np.sort(x, axis=0)
array([[0, 2],
[2, 3]])

>>> ind = np.argsort(x, axis=1) # sorts along last axis (across)

>>> ind
array([[0, 1],
[0, 1]])
>>> np.take_along_axis(x, ind, axis=1) # same as np.sort(x, axis=1)
array([[0, 3],
[2, 2]])

Indices of the sorted elements of a N-dimensional array:

>>> ind = np.unravel_index(np.argsort(x, axis=None), x.shape)

>>> ind
(array([0, 1, 1, 0]), array([0, 0, 1, 1]))
>>> x[ind] # same as np.sort(x, axis=None)
array([0, 2, 2, 3])

Sorting with keys:

>>> x = np.array([(1, 0), (0, 1)], dtype=[('x', '<i4'), ('y', '<i4')])

>>> x
array([(1, 0), (0, 1)],
dtype=[('x', '<i4'), ('y', '<i4')])

>>> np.argsort(x, order=('x','y'))

array([1, 0])

>>> np.argsort(x, order=('y','x'))

array([0, 1])

argwhere(a)
Find the indices of array elements that are non-zero, grouped by element.

Parameters
----------
a : array_like
 Input data.

Returns
-------
index_array : (N, a.ndim) ndarray
Indices of elements that are non-zero. Indices are grouped by element.
This array will have shape ``(N, a.ndim)`` where ``N`` is the number of
non-zero items.

See Also
--------
where, nonzero

Notes
-----
``np.argwhere(a)`` is almost the same as ``np.transpose(np.nonzero(a))``,
but produces a result of the correct shape for a 0D array.

The output of ``argwhere`` is not suitable for indexing arrays.

For this purpose use ``nonzero(a)`` instead.

Examples
--------
>>> x = np.arange(6).reshape(2,3)
>>> x
array([[0, 1, 2],
[3, 4, 5]])
>>> np.argwhere(x>1)
array([[0, 2],
[1, 0],
[1, 1],
[1, 2]])

around(a, decimals=0, out=None)

Round an array to the given number of decimals.

`around` is an alias of `~numpy.round`.

See Also
--------
ndarray.round : equivalent method
round : alias for this function
ceil, fix, floor, rint, trunc

array(...)
array(object, dtype=None, *, copy=True, order='K', subok=False, ndmin=0,
like=None)

Create an array.

Parameters
----------
object : array_like
An array, any object exposing the array interface, an object whose
``__array__`` method returns an array, or any (nested) sequence.
If object is a scalar, a 0-dimensional array containing object is
returned.
dtype : data-type, optional
The desired data-type for the array. If not given, NumPy will try to
use
a default ``dtype`` that can represent the values (by applying
promotion
rules when necessary.)
copy : bool, optional
If true (default), then the object is copied. Otherwise, a copy will
only be made if ``__array__`` returns a copy, if obj is a nested
sequence, or if a copy is needed to satisfy any of the other
requirements (``dtype``, ``order``, etc.).
order : {'K', 'A', 'C', 'F'}, optional
Specify the memory layout of the array. If object is not an array, the
newly created array will be in C order (row major) unless 'F' is
specified, in which case it will be in Fortran order (column major).
If object is an array the following holds.

===== ========= ===================================================

order no copy copy=True
===== ========= ===================================================
'K' unchanged F & C order preserved, otherwise most similar order
'A' unchanged F order if input is F and not C, otherwise C order
'C' C order C order
'F' F order F order
===== ========= ===================================================

When ``copy=False`` and a copy is made for other reasons, the result is
the same as if ``copy=True``, with some exceptions for 'A', see the
Notes section. The default order is 'K'.
subok : bool, optional
If True, then sub-classes will be passed-through, otherwise
the returned array will be forced to be a base-class array (default).
ndmin : int, optional
Specifies the minimum number of dimensions that the resulting
array should have. Ones will be prepended to the shape as
needed to meet this requirement.
like : array_like, optional
Reference object to allow the creation of arrays which are not
NumPy arrays. If an array-like passed in as ``like`` supports
the ``__array_function__`` protocol, the result will be defined
by it. In this case, it ensures the creation of an array object
compatible with that passed in via this argument.

.. versionadded:: 1.20.0

Returns
-------
out : ndarray
An array object satisfying the specified requirements.

See Also
--------
empty_like : Return an empty array with shape and type of input.
ones_like : Return an array of ones with shape and type of input.
zeros_like : Return an array of zeros with shape and type of input.
full_like : Return a new array with shape of input filled with value.
empty : Return a new uninitialized array.
ones : Return a new array setting values to one.
zeros : Return a new array setting values to zero.
full : Return a new array of given shape filled with value.
 Notes
-----
When order is 'A' and ``object`` is an array in neither 'C' nor 'F' order,
and a copy is forced by a change in dtype, then the order of the result is
not necessarily 'C' as expected. This is likely a bug.

Examples
--------
>>> np.array([1, 2, 3])
array([1, 2, 3])

Upcasting:

>>> np.array([1, 2, 3.0])

array([ 1., 2., 3.])

More than one dimension:

>>> np.array([[1, 2], [3, 4]])

array([[1, 2],
[3, 4]])

Minimum dimensions 2:

>>> np.array([1, 2, 3], ndmin=2)

array([[1, 2, 3]])

Type provided:

>>> np.array([1, 2, 3], dtype=complex)

array([ 1.+0.j, 2.+0.j, 3.+0.j])

Data-type consisting of more than one element:

>>> x = np.array([(1,2),(3,4)],dtype=[('a','<i4'),('b','<i4')])
>>> x['a']
array([1, 3])

Creating an array from sub-classes:

>>> np.array(np.mat('1 2; 3 4'))

array([[1, 2],
[3, 4]])

>>> np.array(np.mat('1 2; 3 4'), subok=True)

matrix([[1, 2],
[3, 4]])

array2string(a, max_line_width=None, precision=None, suppress_small=None,

separator=' ', prefix='', style=<no value>, formatter=None, threshold=None,
edgeitems=None, sign=None, floatmode=None, suffix='', *, legacy=None)
Return a string representation of an array.

Parameters
----------
a : ndarray
Input array.
max_line_width : int, optional
 Inserts newlines if text is longer than `max_line_width`.
Defaults to ``numpy.get_printoptions()['linewidth']``.
precision : int or None, optional
Floating point precision.
Defaults to ``numpy.get_printoptions()['precision']``.
suppress_small : bool, optional
Represent numbers "very close" to zero as zero; default is False.
Very close is defined by precision: if the precision is 8, e.g.,
numbers smaller (in absolute value) than 5e-9 are represented as
zero.
Defaults to ``numpy.get_printoptions()['suppress']``.
separator : str, optional
Inserted between elements.
prefix : str, optional
suffix : str, optional
The length of the prefix and suffix strings are used to respectively
align and wrap the output. An array is typically printed as::

prefix + array2string(a) + suffix

The output is left-padded by the length of the prefix string, and

wrapping is forced at the column ``max_line_width - len(suffix)``.
It should be noted that the content of prefix and suffix strings are
not included in the output.
style : _NoValue, optional
Has no effect, do not use.

.. deprecated:: 1.14.0
formatter : dict of callables, optional
If not None, the keys should indicate the type(s) that the respective
formatting function applies to. Callables should return a string.
Types that are not specified (by their corresponding keys) are handled
by the default formatters. Individual types for which a formatter
can be set are:

- 'bool'
- 'int'
- 'timedelta' : a `numpy.timedelta64`
- 'datetime' : a `numpy.datetime64`
- 'float'
- 'longfloat' : 128-bit floats
- 'complexfloat'
- 'longcomplexfloat' : composed of two 128-bit floats
- 'void' : type `numpy.void`
- 'numpystr' : types `numpy.bytes_` and `numpy.str_`

Other keys that can be used to set a group of types at once are:

- 'all' : sets all types

- 'int_kind' : sets 'int'
- 'float_kind' : sets 'float' and 'longfloat'
- 'complex_kind' : sets 'complexfloat' and 'longcomplexfloat'
- 'str_kind' : sets 'numpystr'
threshold : int, optional
Total number of array elements which trigger summarization
rather than full repr.
Defaults to ``numpy.get_printoptions()['threshold']``.
edgeitems : int, optional
Number of array items in summary at beginning and end of
 each dimension.
Defaults to ``numpy.get_printoptions()['edgeitems']``.
sign : string, either '-', '+', or ' ', optional
Controls printing of the sign of floating-point types. If '+', always
print the sign of positive values. If ' ', always prints a space
(whitespace character) in the sign position of positive values. If
'-', omit the sign character of positive values.
Defaults to ``numpy.get_printoptions()['sign']``.
floatmode : str, optional
Controls the interpretation of the `precision` option for
floating-point types.
Defaults to ``numpy.get_printoptions()['floatmode']``.
Can take the following values:

- 'fixed': Always print exactly `precision` fractional digits,

even if this would print more or fewer digits than
necessary to specify the value uniquely.
- 'unique': Print the minimum number of fractional digits necessary
to represent each value uniquely. Different elements may
have a different number of digits. The value of the
`precision` option is ignored.
- 'maxprec': Print at most `precision` fractional digits, but if
an element can be uniquely represented with fewer digits
only print it with that many.
- 'maxprec_equal': Print at most `precision` fractional digits,
but if every element in the array can be uniquely
represented with an equal number of fewer digits, use that
many digits for all elements.
legacy : string or `False`, optional
If set to the string `'1.13'` enables 1.13 legacy printing mode. This
approximates numpy 1.13 print output by including a space in the sign
position of floats and different behavior for 0d arrays. If set to
`False`, disables legacy mode. Unrecognized strings will be ignored
with a warning for forward compatibility.

.. versionadded:: 1.14.0

Returns
-------
array_str : str
String representation of the array.

Raises
------
TypeError
if a callable in `formatter` does not return a string.

See Also
--------
array_str, array_repr, set_printoptions, get_printoptions

Notes
-----
If a formatter is specified for a certain type, the `precision` keyword is
ignored for that type.

This is a very flexible function; `array_repr` and `array_str` are using

`array2string` internally so keywords with the same name should work
identically in all three functions.
 Examples
--------
>>> x = np.array([1e-16,1,2,3])
>>> np.array2string(x, precision=2, separator=',',
... suppress_small=True)
'[0.,1.,2.,3.]'

>>> x = np.arange(3.)
>>> np.array2string(x, formatter={'float_kind':lambda x: "%.2f" % x})
'[0.00 1.00 2.00]'

>>> x = np.arange(3)
>>> np.array2string(x, formatter={'int':lambda x: hex(x)})
'[0x0 0x1 0x2]'

array_equal(a1, a2, equal_nan=False)

True if two arrays have the same shape and elements, False otherwise.

Parameters
----------
a1, a2 : array_like
Input arrays.
equal_nan : bool
Whether to compare NaN's as equal. If the dtype of a1 and a2 is
complex, values will be considered equal if either the real or the
imaginary component of a given value is ``nan``.

.. versionadded:: 1.19.0

Returns
-------
b : bool
Returns True if the arrays are equal.

See Also
--------
allclose: Returns True if two arrays are element-wise equal within a
tolerance.
array_equiv: Returns True if input arrays are shape consistent and all
elements equal.

Examples
--------
>>> np.array_equal([1, 2], [1, 2])
True
>>> np.array_equal(np.array([1, 2]), np.array([1, 2]))
True
>>> np.array_equal([1, 2], [1, 2, 3])
False
>>> np.array_equal([1, 2], [1, 4])
False
>>> a = np.array([1, np.nan])
>>> np.array_equal(a, a)
False
>>> np.array_equal(a, a, equal_nan=True)
True

When ``equal_nan`` is True, complex values with nan components are

 considered equal if either the real *or* the imaginary components are nan.

>>> a = np.array([1 + 1j])

>>> b = a.copy()
>>> a.real = np.nan
>>> b.imag = np.nan
>>> np.array_equal(a, b, equal_nan=True)
True

array_equiv(a1, a2)
Returns True if input arrays are shape consistent and all elements equal.

Shape consistent means they are either the same shape, or one input array
can be broadcasted to create the same shape as the other one.

Parameters
----------
a1, a2 : array_like
Input arrays.

Returns
-------
out : bool
True if equivalent, False otherwise.

Examples
--------
>>> np.array_equiv([1, 2], [1, 2])
True
>>> np.array_equiv([1, 2], [1, 3])
False

Showing the shape equivalence:

>>> np.array_equiv([1, 2], [[1, 2], [1, 2]])

True
>>> np.array_equiv([1, 2], [[1, 2, 1, 2], [1, 2, 1, 2]])
False

>>> np.array_equiv([1, 2], [[1, 2], [1, 3]])

False

array_repr(arr, max_line_width=None, precision=None, suppress_small=None)

Return the string representation of an array.

Parameters
----------
arr : ndarray
Input array.
max_line_width : int, optional
Inserts newlines if text is longer than `max_line_width`.
Defaults to ``numpy.get_printoptions()['linewidth']``.
precision : int, optional
Floating point precision.
Defaults to ``numpy.get_printoptions()['precision']``.
suppress_small : bool, optional
Represent numbers "very close" to zero as zero; default is False.
Very close is defined by precision: if the precision is 8, e.g.,
numbers smaller (in absolute value) than 5e-9 are represented as
 zero.
Defaults to ``numpy.get_printoptions()['suppress']``.

Returns
-------
string : str
The string representation of an array.

See Also
--------
array_str, array2string, set_printoptions

Examples
--------
>>> np.array_repr(np.array([1,2]))
'array([1, 2])'
>>> np.array_repr(np.ma.array([0.]))
'MaskedArray([0.])'
>>> np.array_repr(np.array([], np.int32))
'array([], dtype=int32)'

>>> x = np.array([1e-6, 4e-7, 2, 3])

>>> np.array_repr(x, precision=6, suppress_small=True)
'array([0.000001, 0. , 2. , 3. ])'

array_split(ary, indices_or_sections, axis=0)

Split an array into multiple sub-arrays.

Please refer to the ``split`` documentation. The only difference

between these functions is that ``array_split`` allows
`indices_or_sections` to be an integer that does *not* equally
divide the axis. For an array of length l that should be split
into n sections, it returns l % n sub-arrays of size l//n + 1
and the rest of size l//n.

See Also
--------
split : Split array into multiple sub-arrays of equal size.

Examples
--------
>>> x = np.arange(8.0)
>>> np.array_split(x, 3)
[array([0., 1., 2.]), array([3., 4., 5.]), array([6., 7.])]

>>> x = np.arange(9)
>>> np.array_split(x, 4)
[array([0, 1, 2]), array([3, 4]), array([5, 6]), array([7, 8])]

array_str(a, max_line_width=None, precision=None, suppress_small=None)

Return a string representation of the data in an array.

The data in the array is returned as a single string. This function is

similar to `array_repr`, the difference being that `array_repr` also
returns information on the kind of array and its data type.

Parameters
----------
a : ndarray
 Input array.
max_line_width : int, optional
Inserts newlines if text is longer than `max_line_width`.
Defaults to ``numpy.get_printoptions()['linewidth']``.
precision : int, optional
Floating point precision.
Defaults to ``numpy.get_printoptions()['precision']``.
suppress_small : bool, optional
Represent numbers "very close" to zero as zero; default is False.
Very close is defined by precision: if the precision is 8, e.g.,
numbers smaller (in absolute value) than 5e-9 are represented as
zero.
Defaults to ``numpy.get_printoptions()['suppress']``.

See Also
--------
array2string, array_repr, set_printoptions

Examples
--------
>>> np.array_str(np.arange(3))
'[0 1 2]'

asanyarray(...)
asanyarray(a, dtype=None, order=None, *, like=None)

Convert the input to an ndarray, but pass ndarray subclasses through.

Parameters
----------
a : array_like
Input data, in any form that can be converted to an array. This
includes scalars, lists, lists of tuples, tuples, tuples of tuples,
tuples of lists, and ndarrays.
dtype : data-type, optional
By default, the data-type is inferred from the input data.
order : {'C', 'F', 'A', 'K'}, optional
Memory layout. 'A' and 'K' depend on the order of input array a.
'C' row-major (C-style),
'F' column-major (Fortran-style) memory representation.
'A' (any) means 'F' if `a` is Fortran contiguous, 'C' otherwise
'K' (keep) preserve input order
Defaults to 'C'.
like : array_like, optional
Reference object to allow the creation of arrays which are not
NumPy arrays. If an array-like passed in as ``like`` supports
the ``__array_function__`` protocol, the result will be defined
by it. In this case, it ensures the creation of an array object
compatible with that passed in via this argument.

.. versionadded:: 1.20.0

Returns
-------
out : ndarray or an ndarray subclass
Array interpretation of `a`. If `a` is an ndarray or a subclass
of ndarray, it is returned as-is and no copy is performed.

See Also
 --------
asarray : Similar function which always returns ndarrays.
ascontiguousarray : Convert input to a contiguous array.
asfarray : Convert input to a floating point ndarray.
asfortranarray : Convert input to an ndarray with column-major
memory order.
asarray_chkfinite : Similar function which checks input for NaNs and
Infs.
fromiter : Create an array from an iterator.
fromfunction : Construct an array by executing a function on grid
positions.

Examples
--------
Convert a list into an array:

>>> a = [1, 2]
>>> np.asanyarray(a)
array([1, 2])

Instances of `ndarray` subclasses are passed through as-is:

>>> a = np.array([(1.0, 2), (3.0, 4)], dtype='f4,i4').view(np.recarray)

>>> np.asanyarray(a) is a
True

asarray(...)
asarray(a, dtype=None, order=None, *, like=None)

Convert the input to an array.

Parameters
----------
a : array_like
Input data, in any form that can be converted to an array. This
includes lists, lists of tuples, tuples, tuples of tuples, tuples
of lists and ndarrays.
dtype : data-type, optional
By default, the data-type is inferred from the input data.
order : {'C', 'F', 'A', 'K'}, optional
Memory layout. 'A' and 'K' depend on the order of input array a.
'C' row-major (C-style),
'F' column-major (Fortran-style) memory representation.
'A' (any) means 'F' if `a` is Fortran contiguous, 'C' otherwise
'K' (keep) preserve input order
Defaults to 'K'.
like : array_like, optional
Reference object to allow the creation of arrays which are not
NumPy arrays. If an array-like passed in as ``like`` supports
the ``__array_function__`` protocol, the result will be defined
by it. In this case, it ensures the creation of an array object
compatible with that passed in via this argument.

.. versionadded:: 1.20.0

Returns
-------
out : ndarray
Array interpretation of `a`. No copy is performed if the input
 is already an ndarray with matching dtype and order. If `a` is a
subclass of ndarray, a base class ndarray is returned.

See Also
--------
asanyarray : Similar function which passes through subclasses.
ascontiguousarray : Convert input to a contiguous array.
asfarray : Convert input to a floating point ndarray.
asfortranarray : Convert input to an ndarray with column-major
memory order.
asarray_chkfinite : Similar function which checks input for NaNs and Infs.
fromiter : Create an array from an iterator.
fromfunction : Construct an array by executing a function on grid
positions.

Examples
--------
Convert a list into an array:

>>> a = [1, 2]
>>> np.asarray(a)
array([1, 2])

Existing arrays are not copied:

>>> a = np.array([1, 2])

>>> np.asarray(a) is a
True

If `dtype` is set, array is copied only if dtype does not match:

>>> a = np.array([1, 2], dtype=np.float32)

>>> np.asarray(a, dtype=np.float32) is a
True
>>> np.asarray(a, dtype=np.float64) is a
False

Contrary to `asanyarray`, ndarray subclasses are not passed through:

>>> issubclass(np.recarray, np.ndarray)

True
>>> a = np.array([(1.0, 2), (3.0, 4)], dtype='f4,i4').view(np.recarray)
>>> np.asarray(a) is a
False
>>> np.asanyarray(a) is a
True

asarray_chkfinite(a, dtype=None, order=None)

Convert the input to an array, checking for NaNs or Infs.

Parameters
----------
a : array_like
Input data, in any form that can be converted to an array. This
includes lists, lists of tuples, tuples, tuples of tuples, tuples
of lists and ndarrays. Success requires no NaNs or Infs.
dtype : data-type, optional
By default, the data-type is inferred from the input data.
order : {'C', 'F', 'A', 'K'}, optional
 Memory layout. 'A' and 'K' depend on the order of input array a.
'C' row-major (C-style),
'F' column-major (Fortran-style) memory representation.
'A' (any) means 'F' if `a` is Fortran contiguous, 'C' otherwise
'K' (keep) preserve input order
Defaults to 'C'.

Returns
-------
out : ndarray
Array interpretation of `a`. No copy is performed if the input
is already an ndarray. If `a` is a subclass of ndarray, a base
class ndarray is returned.

Raises
------
ValueError
Raises ValueError if `a` contains NaN (Not a Number) or Inf (Infinity).

See Also
--------
asarray : Create and array.
asanyarray : Similar function which passes through subclasses.
ascontiguousarray : Convert input to a contiguous array.
asfarray : Convert input to a floating point ndarray.
asfortranarray : Convert input to an ndarray with column-major
memory order.
fromiter : Create an array from an iterator.
fromfunction : Construct an array by executing a function on grid
positions.

Examples
--------
Convert a list into an array. If all elements are finite
``asarray_chkfinite`` is identical to ``asarray``.

>>> a = [1, 2]
>>> np.asarray_chkfinite(a, dtype=float)
array([1., 2.])

Raises ValueError if array_like contains Nans or Infs.

>>> a = [1, 2, np.inf]

>>> try:
... np.asarray_chkfinite(a)
... except ValueError:
... print('ValueError')
...
ValueError

ascontiguousarray(...)
ascontiguousarray(a, dtype=None, *, like=None)

Return a contiguous array (ndim >= 1) in memory (C order).

Parameters
----------
a : array_like
Input array.
 dtype : str or dtype object, optional
Data-type of returned array.
like : array_like, optional
Reference object to allow the creation of arrays which are not
NumPy arrays. If an array-like passed in as ``like`` supports
the ``__array_function__`` protocol, the result will be defined
by it. In this case, it ensures the creation of an array object
compatible with that passed in via this argument.

.. versionadded:: 1.20.0

Returns
-------
out : ndarray
Contiguous array of same shape and content as `a`, with type `dtype`
if specified.

See Also
--------
asfortranarray : Convert input to an ndarray with column-major
memory order.
require : Return an ndarray that satisfies requirements.
ndarray.flags : Information about the memory layout of the array.

Examples
--------
Starting with a Fortran-contiguous array:

>>> x = np.ones((2, 3), order='F')

>>> x.flags['F_CONTIGUOUS']
True

Calling ``ascontiguousarray`` makes a C-contiguous copy:

>>> y = np.ascontiguousarray(x)
>>> y.flags['C_CONTIGUOUS']
True
>>> np.may_share_memory(x, y)
False

Now, starting with a C-contiguous array:

>>> x = np.ones((2, 3), order='C')

>>> x.flags['C_CONTIGUOUS']
True

Then, calling ``ascontiguousarray`` returns the same object:

>>> y = np.ascontiguousarray(x)
>>> x is y
True

Note: This function returns an array with at least one-dimension (1-d)

so it will not preserve 0-d arrays.

asfarray(a, dtype=<class 'numpy.float64'>)

Return an array converted to a float type.

Parameters
 ----------
a : array_like
The input array.
dtype : str or dtype object, optional
Float type code to coerce input array `a`. If `dtype` is one of the
'int' dtypes, it is replaced with float64.

Returns
-------
out : ndarray
The input `a` as a float ndarray.

Examples
--------
>>> np.asfarray([2, 3])
array([2., 3.])
>>> np.asfarray([2, 3], dtype='float')
array([2., 3.])
>>> np.asfarray([2, 3], dtype='int8')
array([2., 3.])

asfortranarray(...)
asfortranarray(a, dtype=None, *, like=None)

Return an array (ndim >= 1) laid out in Fortran order in memory.

Parameters
----------
a : array_like
Input array.
dtype : str or dtype object, optional
By default, the data-type is inferred from the input data.
like : array_like, optional
Reference object to allow the creation of arrays which are not
NumPy arrays. If an array-like passed in as ``like`` supports
the ``__array_function__`` protocol, the result will be defined
by it. In this case, it ensures the creation of an array object
compatible with that passed in via this argument.

.. versionadded:: 1.20.0

Returns
-------
out : ndarray
The input `a` in Fortran, or column-major, order.

See Also
--------
ascontiguousarray : Convert input to a contiguous (C order) array.
asanyarray : Convert input to an ndarray with either row or
column-major memory order.
require : Return an ndarray that satisfies requirements.
ndarray.flags : Information about the memory layout of the array.

Examples
--------
Starting with a C-contiguous array:

>>> x = np.ones((2, 3), order='C')

 >>> x.flags['C_CONTIGUOUS']
True

Calling ``asfortranarray`` makes a Fortran-contiguous copy:

>>> y = np.asfortranarray(x)
>>> y.flags['F_CONTIGUOUS']
True
>>> np.may_share_memory(x, y)
False

Now, starting with a Fortran-contiguous array:

>>> x = np.ones((2, 3), order='F')

>>> x.flags['F_CONTIGUOUS']
True

Then, calling ``asfortranarray`` returns the same object:

>>> y = np.asfortranarray(x)
>>> x is y
True

Note: This function returns an array with at least one-dimension (1-d)

so it will not preserve 0-d arrays.

asmatrix(data, dtype=None)
Interpret the input as a matrix.

Unlike `matrix`, `asmatrix` does not make a copy if the input is already
a matrix or an ndarray. Equivalent to ``matrix(data, copy=False)``.

Parameters
----------
data : array_like
Input data.
dtype : data-type
Data-type of the output matrix.

Returns
-------
mat : matrix
`data` interpreted as a matrix.

Examples
--------
>>> x = np.array([[1, 2], [3, 4]])

>>> m = np.asmatrix(x)

>>> x[0,0] = 5

>>> m
matrix([[5, 2],
[3, 4]])

atleast_1d(*arys)
Convert inputs to arrays with at least one dimension.
 Scalar inputs are converted to 1-dimensional arrays, whilst
higher-dimensional inputs are preserved.

Parameters
----------
arys1, arys2, ... : array_like
One or more input arrays.

Returns
-------
ret : ndarray
An array, or list of arrays, each with ``a.ndim >= 1``.
Copies are made only if necessary.

See Also
--------
atleast_2d, atleast_3d

Examples
--------
>>> np.atleast_1d(1.0)
array([1.])

>>> x = np.arange(9.0).reshape(3,3)
>>> np.atleast_1d(x)
array([[0., 1., 2.],
[3., 4., 5.],
[6., 7., 8.]])
>>> np.atleast_1d(x) is x
True

>>> np.atleast_1d(1, [3, 4])

[array([1]), array([3, 4])]

atleast_2d(*arys)
View inputs as arrays with at least two dimensions.

Parameters
----------
arys1, arys2, ... : array_like
One or more array-like sequences. Non-array inputs are converted
to arrays. Arrays that already have two or more dimensions are
preserved.

Returns
-------
res, res2, ... : ndarray
An array, or list of arrays, each with ``a.ndim >= 2``.
Copies are avoided where possible, and views with two or more
dimensions are returned.

See Also
--------
atleast_1d, atleast_3d

Examples
--------
>>> np.atleast_2d(3.0)
array([[3.]])
 >>> x = np.arange(3.0)
>>> np.atleast_2d(x)
array([[0., 1., 2.]])
>>> np.atleast_2d(x).base is x
True

>>> np.atleast_2d(1, [1, 2], [[1, 2]])

[array([[1]]), array([[1, 2]]), array([[1, 2]])]

atleast_3d(*arys)
View inputs as arrays with at least three dimensions.

Parameters
----------
arys1, arys2, ... : array_like
One or more array-like sequences. Non-array inputs are converted to
arrays. Arrays that already have three or more dimensions are
preserved.

Returns
-------
res1, res2, ... : ndarray
An array, or list of arrays, each with ``a.ndim >= 3``. Copies are
avoided where possible, and views with three or more dimensions are
returned. For example, a 1-D array of shape ``(N,)`` becomes a view
of shape ``(1, N, 1)``, and a 2-D array of shape ``(M, N)`` becomes a
view of shape ``(M, N, 1)``.

See Also
--------
atleast_1d, atleast_2d

Examples
--------
>>> np.atleast_3d(3.0)
array([[[3.]]])

>>> x = np.arange(3.0)
>>> np.atleast_3d(x).shape
(1, 3, 1)

>>> x = np.arange(12.0).reshape(4,3)
>>> np.atleast_3d(x).shape
(4, 3, 1)
>>> np.atleast_3d(x).base is x.base # x is a reshape, so not base itself
True

>>> for arr in np.atleast_3d([1, 2], [[1, 2]], [[[1, 2]]]):

... print(arr, arr.shape) # doctest: +SKIP
...
[[[1]
[2]]] (1, 2, 1)
[[[1]
[2]]] (1, 2, 1)
[[[1 2]]] (1, 1, 2)

average(a, axis=None, weights=None, returned=False, *, keepdims=<no value>)

Compute the weighted average along the specified axis.
 Parameters
----------
a : array_like
Array containing data to be averaged. If `a` is not an array, a
conversion is attempted.
axis : None or int or tuple of ints, optional
Axis or axes along which to average `a`. The default,
axis=None, will average over all of the elements of the input array.
If axis is negative it counts from the last to the first axis.

.. versionadded:: 1.7.0

If axis is a tuple of ints, averaging is performed on all of the axes

specified in the tuple instead of a single axis or all the axes as
before.
weights : array_like, optional
An array of weights associated with the values in `a`. Each value in
`a` contributes to the average according to its associated weight.
The weights array can either be 1-D (in which case its length must be
the size of `a` along the given axis) or of the same shape as `a`.
If `weights=None`, then all data in `a` are assumed to have a
weight equal to one. The 1-D calculation is::

avg = sum(a * weights) / sum(weights)

The only constraint on `weights` is that `sum(weights)` must not be 0.

returned : bool, optional
Default is `False`. If `True`, the tuple (`average`, `sum_of_weights`)
is returned, otherwise only the average is returned.
If `weights=None`, `sum_of_weights` is equivalent to the number of
elements over which the average is taken.
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 `a`.
*Note:* `keepdims` will not work with instances of `numpy.matrix`
or other classes whose methods do not support `keepdims`.

.. versionadded:: 1.23.0

Returns
-------
retval, [sum_of_weights] : array_type or double
Return the average along the specified axis. When `returned` is `True`,
return a tuple with the average as the first element and the sum
of the weights as the second element. `sum_of_weights` is of the
same type as `retval`. The result dtype follows a genereal pattern.
If `weights` is None, the result dtype will be that of `a` , or
``float64``
if `a` is integral. Otherwise, if `weights` is not None and `a` is non-
integral, the result type will be the type of lowest precision capable
of
representing values of both `a` and `weights`. If `a` happens to be
integral, the previous rules still applies but the result dtype will
at least be ``float64``.

Raises
------
 ZeroDivisionError
When all weights along axis are zero. See `numpy.ma.average` for a
version robust to this type of error.
TypeError
When the length of 1D `weights` is not the same as the shape of `a`
along axis.

See Also
--------
mean

ma.average : average for masked arrays -- useful if your data contains

"missing" values
numpy.result_type : Returns the type that results from applying the
numpy type promotion rules to the arguments.

Examples
--------
>>> data = np.arange(1, 5)
>>> data
array([1, 2, 3, 4])
>>> np.average(data)
2.5
>>> np.average(np.arange(1, 11), weights=np.arange(10, 0, -1))
4.0

>>> data = np.arange(6).reshape((3, 2))

>>> data
array([[0, 1],
[2, 3],
[4, 5]])
>>> np.average(data, axis=1, weights=[1./4, 3./4])
array([0.75, 2.75, 4.75])
>>> np.average(data, weights=[1./4, 3./4])
Traceback (most recent call last):
...
TypeError: Axis must be specified when shapes of a and weights differ.

>>> a = np.ones(5, dtype=np.float128)

>>> w = np.ones(5, dtype=np.complex64)
>>> avg = np.average(a, weights=w)
>>> print(avg.dtype)
complex256

With ``keepdims=True``, the following result has shape (3, 1).

>>> np.average(data, axis=1, keepdims=True)

array([[0.5],
[2.5],
[4.5]])

bartlett(M)
Return the Bartlett window.

The Bartlett window is very similar to a triangular window, except

that the end points are at zero. It is often used in signal
processing for tapering a signal, without generating too much
ripple in the frequency domain.
 Parameters
----------
M : int
Number of points in the output window. If zero or less, an
empty array is returned.

Returns
-------
out : array
The triangular window, with the maximum value normalized to one
(the value one appears only if the number of samples is odd), with
the first and last samples equal to zero.

See Also
--------
blackman, hamming, hanning, kaiser

Notes
-----
The Bartlett window is defined as

.. math:: w(n) = \frac{2}{M-1} \left(

\frac{M-1}{2} - \left|n - \frac{M-1}{2}\right|
\right)

Most references to the Bartlett window come from the signal processing
literature, where it is used as one of many windowing functions for
smoothing values. Note that convolution with this window produces linear
interpolation. It is also known as an apodization (which means "removing
the foot", i.e. smoothing discontinuities at the beginning and end of the
sampled signal) or tapering function. The Fourier transform of the
Bartlett window is the product of two sinc functions. Note the excellent
discussion in Kanasewich [2]_.

References
----------
.. [1] M.S. Bartlett, "Periodogram Analysis and Continuous Spectra",
Biometrika 37, 1-16, 1950.
.. [2] E.R. Kanasewich, "Time Sequence Analysis in Geophysics",
The University of Alberta Press, 1975, pp. 109-110.
.. [3] A.V. Oppenheim and R.W. Schafer, "Discrete-Time Signal
Processing", Prentice-Hall, 1999, pp. 468-471.
.. [4] Wikipedia, "Window function",
https://en.wikipedia.org/wiki/Window_function
.. [5] W.H. Press, B.P. Flannery, S.A. Teukolsky, and W.T. Vetterling,
"Numerical Recipes", Cambridge University Press, 1986, page 429.

Examples
--------
>>> import matplotlib.pyplot as plt
>>> np.bartlett(12)
array([ 0. , 0.18181818, 0.36363636, 0.54545455, 0.72727273, #
may vary
0.90909091, 0.90909091, 0.72727273, 0.54545455, 0.36363636,
0.18181818, 0. ])

Plot the window and its frequency response (requires SciPy and matplotlib):

>>> from numpy.fft import fft, fftshift

 >>> window = np.bartlett(51)
>>> plt.plot(window)
[<matplotlib.lines.Line2D object at 0x...>]
>>> plt.title("Bartlett window")
Text(0.5, 1.0, 'Bartlett window')
>>> plt.ylabel("Amplitude")
Text(0, 0.5, 'Amplitude')
>>> plt.xlabel("Sample")
Text(0.5, 0, 'Sample')
>>> plt.show()

>>> plt.figure()
<Figure size 640x480 with 0 Axes>
>>> A = fft(window, 2048) / 25.5
>>> mag = np.abs(fftshift(A))
>>> freq = np.linspace(-0.5, 0.5, len(A))
>>> with np.errstate(divide='ignore', invalid='ignore'):
... response = 20 * np.log10(mag)
...
>>> response = np.clip(response, -100, 100)
>>> plt.plot(freq, response)
[<matplotlib.lines.Line2D object at 0x...>]
>>> plt.title("Frequency response of Bartlett window")
Text(0.5, 1.0, 'Frequency response of Bartlett window')
>>> plt.ylabel("Magnitude [dB]")
Text(0, 0.5, 'Magnitude [dB]')
>>> plt.xlabel("Normalized frequency [cycles per sample]")
Text(0.5, 0, 'Normalized frequency [cycles per sample]')
>>> _ = plt.axis('tight')
>>> plt.show()

base_repr(number, base=2, padding=0)

Return a string representation of a number in the given base system.

Parameters
----------
number : int
The value to convert. Positive and negative values are handled.
base : int, optional
Convert `number` to the `base` number system. The valid range is 2-36,
the default value is 2.
padding : int, optional
Number of zeros padded on the left. Default is 0 (no padding).

Returns
-------
out : str
String representation of `number` in `base` system.

See Also
--------
binary_repr : Faster version of `base_repr` for base 2.

Examples
--------
>>> np.base_repr(5)
'101'
>>> np.base_repr(6, 5)
'11'
 >>> np.base_repr(7, base=5, padding=3)
'00012'

>>> np.base_repr(10, base=16)

'A'
>>> np.base_repr(32, base=16)
'20'

binary_repr(num, width=None)
Return the binary representation of the input number as a string.

For negative numbers, if width is not given, a minus sign is added to the
front. If width is given, the two's complement of the number is
returned, with respect to that width.

In a two's-complement system negative numbers are represented by the two's

complement of the absolute value. This is the most common method of
representing signed integers on computers [1]_. A N-bit two's-complement
system can represent every integer in the range
:math:`-2^{N-1}` to :math:`+2^{N-1}-1`.

Parameters
----------
num : int
Only an integer decimal number can be used.
width : int, optional
The length of the returned string if `num` is positive, or the length
of the two's complement if `num` is negative, provided that `width` is
at least a sufficient number of bits for `num` to be represented in the
designated form.

If the `width` value is insufficient, it will be ignored, and `num`

will
be returned in binary (`num` > 0) or two's complement (`num` < 0) form
with its width equal to the minimum number of bits needed to represent
the number in the designated form. This behavior is deprecated and will
later raise an error.

.. deprecated:: 1.12.0

Returns
-------
bin : str
Binary representation of `num` or two's complement of `num`.

See Also
--------
base_repr: Return a string representation of a number in the given base
system.
bin: Python's built-in binary representation generator of an integer.

Notes
-----
`binary_repr` is equivalent to using `base_repr` with base 2, but about 25x
faster.

References
----------
.. [1] Wikipedia, "Two's complement",
 https://en.wikipedia.org/wiki/Two's_complement

Examples
--------
>>> np.binary_repr(3)
'11'
>>> np.binary_repr(-3)
'-11'
>>> np.binary_repr(3, width=4)
'0011'

The two's complement is returned when the input number is negative and
width is specified:

>>> np.binary_repr(-3, width=3)

'101'
>>> np.binary_repr(-3, width=5)
'11101'

bincount(...)
bincount(x, /, weights=None, minlength=0)

Count number of occurrences of each value in array of non-negative ints.

The number of bins (of size 1) is one larger than the largest value in
`x`. If `minlength` is specified, there will be at least this number
of bins in the output array (though it will be longer if necessary,
depending on the contents of `x`).
Each bin gives the number of occurrences of its index value in `x`.
If `weights` is specified the input array is weighted by it, i.e. if a
value ``n`` is found at position ``i``, ``out[n] += weight[i]`` instead
of ``out[n] += 1``.

Parameters
----------
x : array_like, 1 dimension, nonnegative ints
Input array.
weights : array_like, optional
Weights, array of the same shape as `x`.
minlength : int, optional
A minimum number of bins for the output array.

.. versionadded:: 1.6.0

Returns
-------
out : ndarray of ints
The result of binning the input array.
The length of `out` is equal to ``np.amax(x)+1``.

Raises
------
ValueError
If the input is not 1-dimensional, or contains elements with negative
values, or if `minlength` is negative.
TypeError
If the type of the input is float or complex.

See Also
 --------
histogram, digitize, unique

Examples
--------
>>> np.bincount(np.arange(5))
array([1, 1, 1, 1, 1])
>>> np.bincount(np.array([0, 1, 1, 3, 2, 1, 7]))
array([1, 3, 1, 1, 0, 0, 0, 1])

>>> x = np.array([0, 1, 1, 3, 2, 1, 7, 23])

>>> np.bincount(x).size == np.amax(x)+1
True

The input array needs to be of integer dtype, otherwise a

TypeError is raised:

>>> np.bincount(np.arange(5, dtype=float))

Traceback (most recent call last):
...
TypeError: Cannot cast array data from dtype('float64') to dtype('int64')
according to the rule 'safe'

A possible use of ``bincount`` is to perform sums over

variable-size chunks of an array, using the ``weights`` keyword.

>>> w = np.array([0.3, 0.5, 0.2, 0.7, 1., -0.6]) # weights

>>> x = np.array([0, 1, 1, 2, 2, 2])
>>> np.bincount(x, weights=w)
array([ 0.3, 0.7, 1.1])

blackman(M)
Return the Blackman window.

The Blackman window is a taper formed by using the first three

terms of a summation of cosines. It was designed to have close to the
minimal leakage possible. It is close to optimal, only slightly worse
than a Kaiser window.

Parameters
----------
M : int
Number of points in the output window. If zero or less, an empty
array is returned.

Returns
-------
out : ndarray
The window, with the maximum value normalized to one (the value one
appears only if the number of samples is odd).

See Also
--------
bartlett, hamming, hanning, kaiser

Notes
-----
The Blackman window is defined as
.. math:: w(n) = 0.42 - 0.5 \cos(2\pi n/M) + 0.08 \cos(4\pi n/M)

Most references to the Blackman window come from the signal processing
literature, where it is used as one of many windowing functions for
smoothing values. It is also known as an apodization (which means
"removing the foot", i.e. smoothing discontinuities at the beginning
and end of the sampled signal) or tapering function. It is known as a
"near optimal" tapering function, almost as good (by some measures)
as the kaiser window.

References
----------
Blackman, R.B. and Tukey, J.W., (1958) The measurement of power spectra,
Dover Publications, New York.

Oppenheim, A.V., and R.W. Schafer. Discrete-Time Signal Processing.

Upper Saddle River, NJ: Prentice-Hall, 1999, pp. 468-471.

Examples
--------
>>> import matplotlib.pyplot as plt
>>> np.blackman(12)
array([-1.38777878e-17, 3.26064346e-02, 1.59903635e-01, # may vary
4.14397981e-01, 7.36045180e-01, 9.67046769e-01,
9.67046769e-01, 7.36045180e-01, 4.14397981e-01,
1.59903635e-01, 3.26064346e-02, -1.38777878e-17])

Plot the window and the frequency response:

>>> from numpy.fft import fft, fftshift

>>> window = np.blackman(51)
>>> plt.plot(window)
[<matplotlib.lines.Line2D object at 0x...>]
>>> plt.title("Blackman window")
Text(0.5, 1.0, 'Blackman window')
>>> plt.ylabel("Amplitude")
Text(0, 0.5, 'Amplitude')
>>> plt.xlabel("Sample")
Text(0.5, 0, 'Sample')
>>> plt.show()

>>> plt.figure()
<Figure size 640x480 with 0 Axes>
>>> A = fft(window, 2048) / 25.5
>>> mag = np.abs(fftshift(A))
>>> freq = np.linspace(-0.5, 0.5, len(A))
>>> with np.errstate(divide='ignore', invalid='ignore'):
... response = 20 * np.log10(mag)
...
>>> response = np.clip(response, -100, 100)
>>> plt.plot(freq, response)
[<matplotlib.lines.Line2D object at 0x...>]
>>> plt.title("Frequency response of Blackman window")
Text(0.5, 1.0, 'Frequency response of Blackman window')
>>> plt.ylabel("Magnitude [dB]")
Text(0, 0.5, 'Magnitude [dB]')
>>> plt.xlabel("Normalized frequency [cycles per sample]")
Text(0.5, 0, 'Normalized frequency [cycles per sample]')
>>> _ = plt.axis('tight')
 >>> plt.show()

block(arrays)
Assemble an nd-array from nested lists of blocks.

Blocks in the innermost lists are concatenated (see `concatenate`) along

the last dimension (-1), then these are concatenated along the
second-last dimension (-2), and so on until the outermost list is reached.

Blocks can be of any dimension, but will not be broadcasted using the
normal
rules. Instead, leading axes of size 1 are inserted, to make ``block.ndim``
the same for all blocks. This is primarily useful for working with scalars,
and means that code like ``np.block([v, 1])`` is valid, where
``v.ndim == 1``.

When the nested list is two levels deep, this allows block matrices to be
constructed from their components.

.. versionadded:: 1.13.0

Parameters
----------
arrays : nested list of array_like or scalars (but not tuples)
If passed a single ndarray or scalar (a nested list of depth 0), this
is returned unmodified (and not copied).

Elements shapes must match along the appropriate axes (without

broadcasting), but leading 1s will be prepended to the shape as
necessary to make the dimensions match.

Returns
-------
block_array : ndarray
The array assembled from the given blocks.

The dimensionality of the output is equal to the greatest of:

* the dimensionality of all the inputs
* the depth to which the input list is nested

Raises
------
ValueError
* If list depths are mismatched - for instance, ``[[a, b], c]`` is
illegal, and should be spelt ``[[a, b], [c]]``
* If lists are empty - for instance, ``[[a, b], []]``

See Also
--------
concatenate : Join a sequence of arrays along an existing axis.
stack : Join a sequence of arrays along a new axis.
vstack : Stack arrays in sequence vertically (row wise).
hstack : Stack arrays in sequence horizontally (column wise).
dstack : Stack arrays in sequence depth wise (along third axis).
column_stack : Stack 1-D arrays as columns into a 2-D array.
vsplit : Split an array into multiple sub-arrays vertically (row-wise).

Notes
-----
When called with only scalars, ``np.block`` is equivalent to an ndarray
call. So ``np.block([[1, 2], [3, 4]])`` is equivalent to
``np.array([[1, 2], [3, 4]])``.

This function does not enforce that the blocks lie on a fixed grid.
``np.block([[a, b], [c, d]])`` is not restricted to arrays of the form::

AAAbb
AAAbb
cccDD

But is also allowed to produce, for some ``a, b, c, d``::

AAAbb
AAAbb
cDDDD

Since concatenation happens along the last axis first, `block` is _not_
capable of producing the following directly::

AAAbb
cccbb
cccDD

Matlab's "square bracket stacking", ``[A, B, ...; p, q, ...]``, is

equivalent to ``np.block([[A, B, ...], [p, q, ...]])``.

Examples
--------
The most common use of this function is to build a block matrix

>>> A = np.eye(2) * 2
>>> B = np.eye(3) * 3
>>> np.block([
... [A, np.zeros((2, 3))],
... [np.ones((3, 2)), B ]
... ])
array([[2., 0., 0., 0., 0.],
[0., 2., 0., 0., 0.],
[1., 1., 3., 0., 0.],
[1., 1., 0., 3., 0.],
[1., 1., 0., 0., 3.]])

With a list of depth 1, `block` can be used as `hstack`

>>> np.block([1, 2, 3]) # hstack([1, 2, 3])

array([1, 2, 3])

>>> a = np.array([1, 2, 3])

>>> b = np.array([4, 5, 6])
>>> np.block([a, b, 10]) # hstack([a, b, 10])
array([ 1, 2, 3, 4, 5, 6, 10])

>>> A = np.ones((2, 2), int)

>>> B = 2 * A
>>> np.block([A, B]) # hstack([A, B])
array([[1, 1, 2, 2],
[1, 1, 2, 2]])
 With a list of depth 2, `block` can be used in place of `vstack`:

>>> a = np.array([1, 2, 3])

>>> b = np.array([4, 5, 6])
>>> np.block([[a], [b]]) # vstack([a, b])
array([[1, 2, 3],
[4, 5, 6]])

>>> A = np.ones((2, 2), int)

>>> B = 2 * A
>>> np.block([[A], [B]]) # vstack([A, B])
array([[1, 1],
[1, 1],
[2, 2],
[2, 2]])

It can also be used in places of `atleast_1d` and `atleast_2d`

>>> a = np.array(0)
>>> b = np.array([1])
>>> np.block([a]) # atleast_1d(a)
array([0])
>>> np.block([b]) # atleast_1d(b)
array([1])

>>> np.block([[a]]) # atleast_2d(a)

array([[0]])
>>> np.block([[b]]) # atleast_2d(b)
array([[1]])

bmat(obj, ldict=None, gdict=None)

Build a matrix object from a string, nested sequence, or array.

Parameters
----------
obj : str or array_like
Input data. If a string, variables in the current scope may be
referenced by name.
ldict : dict, optional
A dictionary that replaces local operands in current frame.
Ignored if `obj` is not a string or `gdict` is None.
gdict : dict, optional
A dictionary that replaces global operands in current frame.
Ignored if `obj` is not a string.

Returns
-------
out : matrix
Returns a matrix object, which is a specialized 2-D array.

See Also
--------
block :
A generalization of this function for N-d arrays, that returns normal
ndarrays.

Examples
--------
 >>> A = np.mat('1 1; 1 1')
>>> B = np.mat('2 2; 2 2')
>>> C = np.mat('3 4; 5 6')
>>> D = np.mat('7 8; 9 0')

All the following expressions construct the same block matrix:

>>> np.bmat([[A, B], [C, D]])

matrix([[1, 1, 2, 2],
[1, 1, 2, 2],
[3, 4, 7, 8],
[5, 6, 9, 0]])
>>> np.bmat(np.r_[np.c_[A, B], np.c_[C, D]])
matrix([[1, 1, 2, 2],
[1, 1, 2, 2],
[3, 4, 7, 8],
[5, 6, 9, 0]])
>>> np.bmat('A,B; C,D')
matrix([[1, 1, 2, 2],
[1, 1, 2, 2],
[3, 4, 7, 8],
[5, 6, 9, 0]])

broadcast_arrays(*args, subok=False)
Broadcast any number of arrays against each other.

Parameters
----------
`*args` : array_likes
The arrays to broadcast.

subok : bool, optional

If True, then sub-classes will be passed-through, otherwise
the returned arrays will be forced to be a base-class array (default).

Returns
-------
broadcasted : list of arrays
These arrays are views on the original arrays. They are typically
not contiguous. Furthermore, more than one element of a
broadcasted array may refer to a single memory location. If you need
to write to the arrays, make copies first. While you can set the
``writable`` flag True, writing to a single output value may end up
changing more than one location in the output array.

.. deprecated:: 1.17
The output is currently marked so that if written to, a deprecation
warning will be emitted. A future version will set the
``writable`` flag False so writing to it will raise an error.

See Also
--------
broadcast
broadcast_to
broadcast_shapes

Examples
--------
>>> x = np.array([[1,2,3]])
 >>> y = np.array([[4],[5]])
>>> np.broadcast_arrays(x, y)
[array([[1, 2, 3],
[1, 2, 3]]), array([[4, 4, 4],
[5, 5, 5]])]

Here is a useful idiom for getting contiguous copies instead of

non-contiguous views.

>>> [np.array(a) for a in np.broadcast_arrays(x, y)]

[array([[1, 2, 3],
[1, 2, 3]]), array([[4, 4, 4],
[5, 5, 5]])]

broadcast_shapes(*args)
Broadcast the input shapes into a single shape.

:ref:`Learn more about broadcasting here <basics.broadcasting>`.

.. versionadded:: 1.20.0

Parameters
----------
`*args` : tuples of ints, or ints
The shapes to be broadcast against each other.

Returns
-------
tuple
Broadcasted shape.

Raises
------
ValueError
If the shapes are not compatible and cannot be broadcast according
to NumPy's broadcasting rules.

See Also
--------
broadcast
broadcast_arrays
broadcast_to

Examples
--------
>>> np.broadcast_shapes((1, 2), (3, 1), (3, 2))
(3, 2)

>>> np.broadcast_shapes((6, 7), (5, 6, 1), (7,), (5, 1, 7))

(5, 6, 7)

broadcast_to(array, shape, subok=False)

Broadcast an array to a new shape.

Parameters
----------
array : array_like
The array to broadcast.
shape : tuple or int
 The shape of the desired array. A single integer ``i`` is interpreted
as ``(i,)``.
subok : bool, optional
If True, then sub-classes will be passed-through, otherwise
the returned array will be forced to be a base-class array (default).

Returns
-------
broadcast : array
A readonly view on the original array with the given shape. It is
typically not contiguous. Furthermore, more than one element of a
broadcasted array may refer to a single memory location.

Raises
------
ValueError
If the array is not compatible with the new shape according to NumPy's
broadcasting rules.

See Also
--------
broadcast
broadcast_arrays
broadcast_shapes

Notes
-----
.. versionadded:: 1.10.0

Examples
--------
>>> x = np.array([1, 2, 3])
>>> np.broadcast_to(x, (3, 3))
array([[1, 2, 3],
[1, 2, 3],
[1, 2, 3]])

busday_count(...)
busday_count(begindates, enddates, weekmask='1111100', holidays=[],
busdaycal=None, out=None)

Counts the number of valid days between `begindates` and

`enddates`, not including the day of `enddates`.

If ``enddates`` specifies a date value that is earlier than the

corresponding ``begindates`` date value, the count will be negative.

.. versionadded:: 1.7.0

Parameters
----------
begindates : array_like of datetime64[D]
The array of the first dates for counting.
enddates : array_like of datetime64[D]
The array of the end dates for counting, which are excluded
from the count themselves.
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. They 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.
busdaycal : busdaycalendar, optional
A `busdaycalendar` object which specifies the valid days. If this
parameter is provided, neither weekmask nor holidays may be
provided.
out : array of int, optional
If provided, this array is filled with the result.

Returns
-------
out : array of int
An array with a shape from broadcasting ``begindates`` and ``enddates``
together, containing the number of valid days between
the begin and end dates.

See Also
--------
busdaycalendar : An object that specifies a custom set of valid days.
is_busday : Returns a boolean array indicating valid days.
busday_offset : Applies an offset counted in valid days.

Examples
--------
>>> # Number of weekdays in January 2011
... np.busday_count('2011-01', '2011-02')
21
>>> # Number of weekdays in 2011
>>> np.busday_count('2011', '2012')
260
>>> # Number of Saturdays in 2011
... np.busday_count('2011', '2012', weekmask='Sat')
53

busday_offset(...)
busday_offset(dates, offsets, roll='raise', weekmask='1111100',
holidays=None, busdaycal=None, out=None)

First adjusts the date to fall on a valid day according to

the ``roll`` rule, then applies offsets to the given dates
counted in valid days.

.. versionadded:: 1.7.0

Parameters
----------
dates : array_like of datetime64[D]
The array of dates to process.
offsets : array_like of int
The array of offsets, which is broadcast with ``dates``.
roll : {'raise', 'nat', 'forward', 'following', 'backward', 'preceding',
'modifiedfollowing', 'modifiedpreceding'}, optional
 How to treat dates that do not fall on a valid day. The default
is 'raise'.

* 'raise' means to raise an exception for an invalid day.

* 'nat' means to return a NaT (not-a-time) for an invalid day.
* 'forward' and 'following' mean to take the first valid day
later in time.
* 'backward' and 'preceding' mean to take the first valid day
earlier in time.
* 'modifiedfollowing' means to take the first valid day
later in time unless it is across a Month boundary, in which
case to take the first valid day earlier in time.
* 'modifiedpreceding' means to take the first valid day
earlier in time unless it is across a Month boundary, in which
case to take the first valid day later in time.
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. They 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.
busdaycal : busdaycalendar, optional
A `busdaycalendar` object which specifies the valid days. If this
parameter is provided, neither weekmask nor holidays may be
provided.
out : array of datetime64[D], optional
If provided, this array is filled with the result.

Returns
-------
out : array of datetime64[D]
An array with a shape from broadcasting ``dates`` and ``offsets``
together, containing the dates with offsets applied.

See Also
--------
busdaycalendar : An object that specifies a custom set of valid days.
is_busday : Returns a boolean array indicating valid days.
busday_count : Counts how many valid days are in a half-open date range.

Examples
--------
>>> # First business day in October 2011 (not accounting for holidays)
... np.busday_offset('2011-10', 0, roll='forward')
numpy.datetime64('2011-10-03')
>>> # Last business day in February 2012 (not accounting for holidays)
... np.busday_offset('2012-03', -1, roll='forward')
numpy.datetime64('2012-02-29')
>>> # Third Wednesday in January 2011
... np.busday_offset('2011-01', 2, roll='forward', weekmask='Wed')
numpy.datetime64('2011-01-19')
>>> # 2012 Mother's Day in Canada and the U.S.
... np.busday_offset('2012-05', 1, roll='forward', weekmask='Sun')
 numpy.datetime64('2012-05-13')

>>> # First business day on or after a date

... np.busday_offset('2011-03-20', 0, roll='forward')
numpy.datetime64('2011-03-21')
>>> np.busday_offset('2011-03-22', 0, roll='forward')
numpy.datetime64('2011-03-22')
>>> # First business day after a date
... np.busday_offset('2011-03-20', 1, roll='backward')
numpy.datetime64('2011-03-21')
>>> np.busday_offset('2011-03-22', 1, roll='backward')
numpy.datetime64('2011-03-23')

byte_bounds(a)
Returns pointers to the end-points of an array.

Parameters
----------
a : ndarray
Input array. It must conform to the Python-side of the array
interface.

Returns
-------
(low, high) : tuple of 2 integers
The first integer is the first byte of the array, the second
integer is just past the last byte of the array. If `a` is not
contiguous it will not use every byte between the (`low`, `high`)
values.

Examples
--------
>>> I = np.eye(2, dtype='f'); I.dtype
dtype('float32')
>>> low, high = np.byte_bounds(I)
>>> high - low == I.size*I.itemsize
True
>>> I = np.eye(2); I.dtype
dtype('float64')
>>> low, high = np.byte_bounds(I)
>>> high - low == I.size*I.itemsize
True

can_cast(...)
can_cast(from_, to, casting='safe')

Returns True if cast between data types can occur according to the
casting rule. If from is a scalar or array scalar, also returns
True if the scalar value can be cast without overflow or truncation
to an integer.

Parameters
----------
from_ : dtype, dtype specifier, scalar, or array
Data type, scalar, or array to cast from.
to : dtype or dtype specifier
Data type to cast to.
casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
Controls what kind of data casting may occur.
 * '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.

Returns
-------
out : bool
True if cast can occur according to the casting rule.

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 maximum
integer/float value converted.

See also
--------
dtype, result_type

Examples
--------
Basic examples

>>> np.can_cast(np.int32, np.int64)

True
>>> np.can_cast(np.float64, complex)
True
>>> np.can_cast(complex, float)
False

>>> np.can_cast('i8', 'f8')

True
>>> np.can_cast('i8', 'f4')
False
>>> np.can_cast('i4', 'S4')
False

Casting scalars

>>> np.can_cast(100, 'i1')

True
>>> np.can_cast(150, 'i1')
False
>>> np.can_cast(150, 'u1')
True

>>> np.can_cast(3.5e100, np.float32)

False
>>> np.can_cast(1000.0, np.float32)
 True

Array scalar checks the value, array does not

>>> np.can_cast(np.array(1000.0), np.float32)

True
>>> np.can_cast(np.array([1000.0]), np.float32)
False

Using the casting rules

>>> np.can_cast('i8', 'i8', 'no')

True
>>> np.can_cast('<i8', '>i8', 'no')
False

>>> np.can_cast('<i8', '>i8', 'equiv')

True
>>> np.can_cast('<i4', '>i8', 'equiv')
False

>>> np.can_cast('<i4', '>i8', 'safe')

True
>>> np.can_cast('<i8', '>i4', 'safe')
False

>>> np.can_cast('<i8', '>i4', 'same_kind')

True
>>> np.can_cast('<i8', '>u4', 'same_kind')
False

>>> np.can_cast('<i8', '>u4', 'unsafe')

True

choose(a, choices, out=None, mode='raise')

Construct an array from an index array and a list of arrays to choose from.

First of all, if confused or uncertain, definitely look at the Examples -

in its full generality, this function is less simple than it might
seem from the following code description (below ndi =
`numpy.lib.index_tricks`):

``np.choose(a,c) == np.array([c[a[I]][I] for I in ndi.ndindex(a.shape)])``.

But this omits some subtleties. Here is a fully general summary:

Given an "index" array (`a`) of integers and a sequence of ``n`` arrays

(`choices`), `a` and each choice array are first broadcast, as necessary,
to arrays of a common shape; calling these *Ba* and *Bchoices[i], i =
0,...,n-1* we have that, necessarily, ``Ba.shape == Bchoices[i].shape``
for each ``i``. Then, a new array with shape ``Ba.shape`` is created as
follows:

* if ``mode='raise'`` (the default), then, first of all, each element of

``a`` (and thus ``Ba``) must be in the range ``[0, n-1]``; now, suppose
that ``i`` (in that range) is the value at the ``(j0, j1, ..., jm)``
position in ``Ba`` - then the value at the same position in the new array
is the value in ``Bchoices[i]`` at that same position;
* if ``mode='wrap'``, values in `a` (and thus `Ba`) may be any (signed)
integer; modular arithmetic is used to map integers outside the range
`[0, n-1]` back into that range; and then the new array is constructed
as above;

* if ``mode='clip'``, values in `a` (and thus ``Ba``) may be any (signed)

integer; negative integers are mapped to 0; values greater than ``n-1``
are mapped to ``n-1``; and then the new array is constructed as above.

Parameters
----------
a : int array
This array must contain integers in ``[0, n-1]``, where ``n`` is the
number of choices, unless ``mode=wrap`` or ``mode=clip``, in which
cases any integers are permissible.
choices : sequence of arrays
Choice arrays. `a` and all of the choices must be broadcastable to the
same shape. If `choices` is itself an array (not recommended), then
its outermost dimension (i.e., the one corresponding to
``choices.shape[0]``) is taken as defining the "sequence".
out : array, optional
If provided, the result will be inserted into this array. It should
be of the appropriate shape and dtype. Note that `out` is always
buffered if ``mode='raise'``; use other modes for better performance.
mode : {'raise' (default), 'wrap', 'clip'}, optional
Specifies how indices outside ``[0, n-1]`` will be treated:

* 'raise' : an exception is raised

* 'wrap' : value becomes value mod ``n``
* 'clip' : values < 0 are mapped to 0, values > n-1 are mapped to n-1

Returns
-------
merged_array : array
The merged result.

Raises
------
ValueError: shape mismatch
If `a` and each choice array are not all broadcastable to the same
shape.

See Also
--------
ndarray.choose : equivalent method
numpy.take_along_axis : Preferable if `choices` is an array

Notes
-----
To reduce the chance of misinterpretation, even though the following
"abuse" is nominally supported, `choices` should neither be, nor be
thought of as, a single array, i.e., the outermost sequence-like container
should be either a list or a tuple.

Examples
--------

>>> choices = [[0, 1, 2, 3], [10, 11, 12, 13],

... [20, 21, 22, 23], [30, 31, 32, 33]]
 >>> np.choose([2, 3, 1, 0], choices
... # the first element of the result will be the first element of the
... # third (2+1) "array" in choices, namely, 20; the second element
... # will be the second element of the fourth (3+1) choice array, i.e.,
... # 31, etc.
... )
array([20, 31, 12, 3])
>>> np.choose([2, 4, 1, 0], choices, mode='clip') # 4 goes to 3 (4-1)
array([20, 31, 12, 3])
>>> # because there are 4 choice arrays
>>> np.choose([2, 4, 1, 0], choices, mode='wrap') # 4 goes to (4 mod 4)
array([20, 1, 12, 3])
>>> # i.e., 0

A couple examples illustrating how choose broadcasts:

>>> a = [[1, 0, 1], [0, 1, 0], [1, 0, 1]]

>>> choices = [-10, 10]
>>> np.choose(a, choices)
array([[ 10, -10, 10],
[-10, 10, -10],
[ 10, -10, 10]])

>>> # With thanks to Anne Archibald

>>> a = np.array([0, 1]).reshape((2,1,1))
>>> c1 = np.array([1, 2, 3]).reshape((1,3,1))
>>> c2 = np.array([-1, -2, -3, -4, -5]).reshape((1,1,5))
>>> np.choose(a, (c1, c2)) # result is 2x3x5, res[0,:,:]=c1, res[1,:,:]=c2
array([[[ 1, 1, 1, 1, 1],
[ 2, 2, 2, 2, 2],
[ 3, 3, 3, 3, 3]],
[[-1, -2, -3, -4, -5],
[-1, -2, -3, -4, -5],
[-1, -2, -3, -4, -5]]])

clip(a, a_min, a_max, out=None, **kwargs)

Clip (limit) the values in an array.

Given an interval, values outside the interval are clipped to

the interval edges. For example, if an interval of ``[0, 1]``
is specified, values smaller than 0 become 0, and values larger
than 1 become 1.

Equivalent to but faster than ``np.minimum(a_max, np.maximum(a, a_min))``.

No check is performed to ensure ``a_min < a_max``.

Parameters
----------
a : array_like
Array containing elements to clip.
a_min, a_max : array_like or None
Minimum and maximum value. If ``None``, clipping is not performed on
the corresponding edge. Only one of `a_min` and `a_max` may be
``None``. Both are broadcast against `a`.
out : ndarray, optional
The results will be placed in this array. It may be the input
array for in-place clipping. `out` must be of the right shape
to hold the output. Its type is preserved.
 **kwargs
For other keyword-only arguments, see the
:ref:`ufunc docs <ufuncs.kwargs>`.

.. versionadded:: 1.17.0

Returns
-------
clipped_array : ndarray
An array with the elements of `a`, but where values
< `a_min` are replaced with `a_min`, and those > `a_max`
with `a_max`.

See Also
--------
:ref:`ufuncs-output-type`

Notes
-----
When `a_min` is greater than `a_max`, `clip` returns an
array in which all values are equal to `a_max`,
as shown in the second example.

Examples
--------
>>> a = np.arange(10)
>>> a
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> np.clip(a, 1, 8)
array([1, 1, 2, 3, 4, 5, 6, 7, 8, 8])
>>> np.clip(a, 8, 1)
array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1])
>>> np.clip(a, 3, 6, out=a)
array([3, 3, 3, 3, 4, 5, 6, 6, 6, 6])
>>> a
array([3, 3, 3, 3, 4, 5, 6, 6, 6, 6])
>>> a = np.arange(10)
>>> a
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> np.clip(a, [3, 4, 1, 1, 1, 4, 4, 4, 4, 4], 8)
array([3, 4, 2, 3, 4, 5, 6, 7, 8, 8])

column_stack(tup)
Stack 1-D arrays as columns into a 2-D array.

Take a sequence of 1-D arrays and stack them as columns

to make a single 2-D array. 2-D arrays are stacked as-is,
just like with `hstack`. 1-D arrays are turned into 2-D columns
first.

Parameters
----------
tup : sequence of 1-D or 2-D arrays.
Arrays to stack. All of them must have the same first dimension.

Returns
-------
stacked : 2-D array
The array formed by stacking the given arrays.
 See Also
--------
stack, hstack, vstack, concatenate

Examples
--------
>>> a = np.array((1,2,3))
>>> b = np.array((2,3,4))
>>> np.column_stack((a,b))
array([[1, 2],
[2, 3],
[3, 4]])

common_type(*arrays)
Return a scalar type which is common to the input arrays.

The return type will always be an inexact (i.e. floating point) scalar
type, even if all the arrays are integer arrays. If one of the inputs is
an integer array, the minimum precision type that is returned is a
64-bit floating point dtype.

All input arrays except int64 and uint64 can be safely cast to the
returned dtype without loss of information.

Parameters
----------
array1, array2, ... : ndarrays
Input arrays.

Returns
-------
out : data type code
Data type code.

See Also
--------
dtype, mintypecode

Examples
--------
>>> np.common_type(np.arange(2, dtype=np.float32))
<class 'numpy.float32'>
>>> np.common_type(np.arange(2, dtype=np.float32), np.arange(2))
<class 'numpy.float64'>
>>> np.common_type(np.arange(4), np.array([45, 6.j]), np.array([45.0]))
<class 'numpy.complex128'>

compare_chararrays(...)
compare_chararrays(a1, a2, cmp, rstrip)

Performs element-wise comparison of two string arrays using the

comparison operator specified by `cmp_op`.

Parameters
----------
a1, a2 : array_like
Arrays to be compared.
cmp : {"<", "<=", "==", ">=", ">", "!="}
 Type of comparison.
rstrip : Boolean
If True, the spaces at the end of Strings are removed before the
comparison.

Returns
-------
out : ndarray
The output array of type Boolean with the same shape as a and b.

Raises
------
ValueError
If `cmp_op` is not valid.
TypeError
If at least one of `a` or `b` is a non-string array

Examples
--------
>>> a = np.array(["a", "b", "cde"])
>>> b = np.array(["a", "a", "dec"])
>>> np.compare_chararrays(a, b, ">", True)
array([False, True, False])

compress(condition, a, axis=None, out=None)

Return selected slices of an array along given axis.

When working along a given axis, a slice along that axis is returned in
`output` for each index where `condition` evaluates to True. When
working on a 1-D array, `compress` is equivalent to `extract`.

Parameters
----------
condition : 1-D array of bools
Array that selects which entries to return. If len(condition)
is less than the size of `a` along the given axis, then output is
truncated to the length of the condition array.
a : array_like
Array from which to extract a part.
axis : int, optional
Axis along which to take slices. If None (default), work on the
flattened array.
out : ndarray, optional
Output array. Its type is preserved and it must be of the right
shape to hold the output.

Returns
-------
compressed_array : ndarray
A copy of `a` without the slices along axis for which `condition`
is false.

See Also
--------
take, choose, diag, diagonal, select
ndarray.compress : Equivalent method in ndarray
extract : Equivalent method when working on 1-D arrays
:ref:`ufuncs-output-type`
 Examples
--------
>>> a = np.array([[1, 2], [3, 4], [5, 6]])
>>> a
array([[1, 2],
[3, 4],
[5, 6]])
>>> np.compress([0, 1], a, axis=0)
array([[3, 4]])
>>> np.compress([False, True, True], a, axis=0)
array([[3, 4],
[5, 6]])
>>> np.compress([False, True], a, axis=1)
array([[2],
[4],
[6]])

Working on the flattened array does not return slices along an axis but
selects elements.

>>> np.compress([False, True], a)

array([2])

concatenate(...)
concatenate((a1, a2, ...), axis=0, out=None, dtype=None,
casting="same_kind")

Join a sequence of arrays along an existing axis.

Parameters
----------
a1, a2, ... : sequence of array_like
The arrays must have the same shape, except in the dimension
corresponding to `axis` (the first, by default).
axis : int, optional
The axis along which the arrays will be joined. If axis is None,
arrays are flattened before use. Default is 0.
out : ndarray, optional
If provided, the destination to place the result. The shape must be
correct, matching that of what concatenate would have returned if no
out argument were specified.
dtype : str or dtype
If provided, the destination array will have this dtype. Cannot be
provided together with `out`.

.. versionadded:: 1.20.0

casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional

Controls what kind of data casting may occur. Defaults to 'same_kind'.

.. versionadded:: 1.20.0

Returns
-------
res : ndarray
The concatenated array.

See Also
--------
 ma.concatenate : Concatenate function that preserves input masks.
array_split : Split an array into multiple sub-arrays of equal or
near-equal size.
split : Split array into a list of multiple sub-arrays of equal size.
hsplit : Split array into multiple sub-arrays horizontally (column wise).
vsplit : Split array into multiple sub-arrays vertically (row wise).
dsplit : Split array into multiple sub-arrays along the 3rd axis (depth).
stack : Stack a sequence of arrays along a new axis.
block : Assemble arrays from blocks.
hstack : Stack arrays in sequence horizontally (column wise).
vstack : Stack arrays in sequence vertically (row wise).
dstack : Stack arrays in sequence depth wise (along third dimension).
column_stack : Stack 1-D arrays as columns into a 2-D array.

Notes
-----
When one or more of the arrays to be concatenated is a MaskedArray,
this function will return a MaskedArray object instead of an ndarray,
but the input masks are *not* preserved. In cases where a MaskedArray
is expected as input, use the ma.concatenate function from the masked
array module instead.

Examples
--------
>>> a = np.array([[1, 2], [3, 4]])
>>> b = np.array([[5, 6]])
>>> np.concatenate((a, b), axis=0)
array([[1, 2],
[3, 4],
[5, 6]])
>>> np.concatenate((a, b.T), axis=1)
array([[1, 2, 5],
[3, 4, 6]])
>>> np.concatenate((a, b), axis=None)
array([1, 2, 3, 4, 5, 6])

This function will not preserve masking of MaskedArray inputs.

>>> a = np.ma.arange(3)
>>> a[1] = np.ma.masked
>>> b = np.arange(2, 5)
>>> a
masked_array(data=[0, --, 2],
mask=[False, True, False],
fill_value=999999)
>>> b
array([2, 3, 4])
>>> np.concatenate([a, b])
masked_array(data=[0, 1, 2, 2, 3, 4],
mask=False,
fill_value=999999)
>>> np.ma.concatenate([a, b])
masked_array(data=[0, --, 2, 2, 3, 4],
mask=[False, True, False, False, False, False],
fill_value=999999)

convolve(a, v, mode='full')
Returns the discrete, linear convolution of two one-dimensional sequences.
The convolution operator is often seen in signal processing, where it
models the effect of a linear time-invariant system on a signal [1]_. In
probability theory, the sum of two independent random variables is
distributed according to the convolution of their individual
distributions.

If `v` is longer than `a`, the arrays are swapped before computation.

Parameters
----------
a : (N,) array_like
First one-dimensional input array.
v : (M,) array_like
Second one-dimensional input array.
mode : {'full', 'valid', 'same'}, optional
'full':
By default, mode is 'full'. This returns the convolution
at each point of overlap, with an output shape of (N+M-1,). At
the end-points of the convolution, the signals do not overlap
completely, and boundary effects may be seen.

'same':
Mode 'same' returns output of length ``max(M, N)``. Boundary
effects are still visible.

'valid':
Mode 'valid' returns output of length
``max(M, N) - min(M, N) + 1``. The convolution product is only given
for points where the signals overlap completely. Values outside
the signal boundary have no effect.

Returns
-------
out : ndarray
Discrete, linear convolution of `a` and `v`.

See Also
--------
scipy.signal.fftconvolve : Convolve two arrays using the Fast Fourier
Transform.
scipy.linalg.toeplitz : Used to construct the convolution operator.
polymul : Polynomial multiplication. Same output as convolve, but also
accepts poly1d objects as input.

Notes
-----
The discrete convolution operation is defined as

.. math:: (a * v)_n = \sum_{m = -\infty}^{\infty} a_m v_{n - m}

It can be shown that a convolution :math:`x(t) * y(t)` in time/space

is equivalent to the multiplication :math:`X(f) Y(f)` in the Fourier
domain, after appropriate padding (padding is necessary to prevent
circular convolution). Since multiplication is more efficient (faster)
than convolution, the function `scipy.signal.fftconvolve` exploits the
FFT to calculate the convolution of large data-sets.

References
----------
 .. [1] Wikipedia, "Convolution",
https://en.wikipedia.org/wiki/Convolution

Examples
--------
Note how the convolution operator flips the second array
before "sliding" the two across one another:

>>> np.convolve([1, 2, 3], [0, 1, 0.5])

array([0. , 1. , 2.5, 4. , 1.5])

Only return the middle values of the convolution.

Contains boundary effects, where zeros are taken
into account:

>>> np.convolve([1,2,3],[0,1,0.5], 'same')

array([1. , 2.5, 4. ])

The two arrays are of the same length, so there

is only one position where they completely overlap:

>>> np.convolve([1,2,3],[0,1,0.5], 'valid')

array([2.5])

copy(a, order='K', subok=False)

Return an array copy of the given object.

Parameters
----------
a : array_like
Input data.
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 :meth:`ndarray.copy` are very
similar, but have different default values for their order=
arguments.)
subok : bool, optional
If True, then sub-classes will be passed-through, otherwise the
returned array will be forced to be a base-class array (defaults to
False).

.. versionadded:: 1.19.0

Returns
-------
arr : ndarray
Array interpretation of `a`.

See Also
--------
ndarray.copy : Preferred method for creating an array copy

Notes
-----
This is equivalent to:

>>> np.array(a, copy=True) #doctest: +SKIP

 Examples
--------
Create an array x, with a reference y and a copy z:

>>> x = np.array([1, 2, 3])

>>> y = x
>>> z = np.copy(x)

Note that, when we modify x, y changes, but not z:

>>> x[0] = 10
>>> x[0] == y[0]
True
>>> x[0] == z[0]
False

Note that, np.copy clears previously set WRITEABLE=False flag.

>>> a = np.array([1, 2, 3])

>>> a.flags["WRITEABLE"] = False
>>> b = np.copy(a)
>>> b.flags["WRITEABLE"]
True
>>> b[0] = 3
>>> b
array([3, 2, 3])

Note that np.copy is a shallow copy and will not copy object
elements within arrays. This is mainly important for arrays
containing Python objects. The new array will contain the
same object which may lead to surprises if that object can
be modified (is mutable):

>>> a = np.array([1, 'm', [2, 3, 4]], dtype=object)

>>> b = np.copy(a)
>>> b[2][0] = 10
>>> a
array([1, 'm', list([10, 3, 4])], dtype=object)

To ensure all elements within an ``object`` array are copied,

use `copy.deepcopy`:

>>> import copy

>>> a = np.array([1, 'm', [2, 3, 4]], dtype=object)
>>> c = copy.deepcopy(a)
>>> c[2][0] = 10
>>> c
array([1, 'm', list([10, 3, 4])], dtype=object)
>>> a
array([1, 'm', list([2, 3, 4])], dtype=object)

copyto(...)
copyto(dst, src, casting='same_kind', where=True)

Copies values from one array to another, broadcasting as necessary.

Raises a TypeError if the `casting` rule is violated, and if

`where` is provided, it selects which elements to copy.
 .. versionadded:: 1.7.0

Parameters
----------
dst : ndarray
The array into which values are copied.
src : array_like
The array from which values are copied.
casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
Controls what kind of data casting may occur when copying.

* '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.
where : array_like of bool, optional
A boolean array which is broadcasted to match the dimensions
of `dst`, and selects elements to copy from `src` to `dst`
wherever it contains the value True.

Examples
--------
>>> A = np.array([4, 5, 6])
>>> B = [1, 2, 3]
>>> np.copyto(A, B)
>>> A
array([1, 2, 3])

>>> A = np.array([[1, 2, 3], [4, 5, 6]])

>>> B = [[4, 5, 6], [7, 8, 9]]
>>> np.copyto(A, B)
>>> A
array([[4, 5, 6],
[7, 8, 9]])

corrcoef(x, y=None, rowvar=True, bias=<no value>, ddof=<no value>, *,

dtype=None)
Return Pearson product-moment correlation coefficients.

Please refer to the documentation for `cov` for more detail. The
relationship between the correlation coefficient matrix, `R`, and the
covariance matrix, `C`, is

.. math:: R_{ij} = \frac{ C_{ij} } { \sqrt{ C_{ii} C_{jj} } }

The values of `R` are between -1 and 1, inclusive.

Parameters
----------
x : array_like
A 1-D or 2-D array containing multiple variables and observations.
Each row of `x` represents a variable, and each column a single
observation of all those variables. Also see `rowvar` below.
y : array_like, optional
An additional set of variables and observations. `y` has the same
shape as `x`.
rowvar : bool, optional
If `rowvar` is True (default), then each row represents a
variable, with observations in the columns. Otherwise, the relationship
is transposed: each column represents a variable, while the rows
contain observations.
bias : _NoValue, optional
Has no effect, do not use.

.. deprecated:: 1.10.0
ddof : _NoValue, optional
Has no effect, do not use.

.. deprecated:: 1.10.0
dtype : data-type, optional
Data-type of the result. By default, the return data-type will have
at least `numpy.float64` precision.

.. versionadded:: 1.20

Returns
-------
R : ndarray
The correlation coefficient matrix of the variables.

See Also
--------
cov : Covariance matrix

Notes
-----
Due to floating point rounding the resulting array may not be Hermitian,
the diagonal elements may not be 1, and the elements may not satisfy the
inequality abs(a) <= 1. The real and imaginary parts are clipped to the
interval [-1, 1] in an attempt to improve on that situation but is not
much help in the complex case.

This function accepts but discards arguments `bias` and `ddof`. This is
for backwards compatibility with previous versions of this function. These
arguments had no effect on the return values of the function and can be
safely ignored in this and previous versions of numpy.

Examples
--------
In this example we generate two random arrays, ``xarr`` and ``yarr``, and
compute the row-wise and column-wise Pearson correlation coefficients,
``R``. Since ``rowvar`` is true by default, we first find the row-wise
Pearson correlation coefficients between the variables of ``xarr``.

>>> import numpy as np

>>> rng = np.random.default_rng(seed=42)
>>> xarr = rng.random((3, 3))
>>> xarr
array([[0.77395605, 0.43887844, 0.85859792],
[0.69736803, 0.09417735, 0.97562235],
[0.7611397 , 0.78606431, 0.12811363]])
>>> R1 = np.corrcoef(xarr)
>>> R1
array([[ 1. , 0.99256089, -0.68080986],
[ 0.99256089, 1. , -0.76492172],
 [-0.68080986, -0.76492172, 1. ]])

If we add another set of variables and observations ``yarr``, we can

compute the row-wise Pearson correlation coefficients between the
variables in ``xarr`` and ``yarr``.

>>> yarr = rng.random((3, 3))

>>> yarr
array([[0.45038594, 0.37079802, 0.92676499],
[0.64386512, 0.82276161, 0.4434142 ],
[0.22723872, 0.55458479, 0.06381726]])
>>> R2 = np.corrcoef(xarr, yarr)
>>> R2
array([[ 1. , 0.99256089, -0.68080986, 0.75008178, -0.934284 ,
-0.99004057],
[ 0.99256089, 1. , -0.76492172, 0.82502011, -0.97074098,
-0.99981569],
[-0.68080986, -0.76492172, 1. , -0.99507202, 0.89721355,
0.77714685],
[ 0.75008178, 0.82502011, -0.99507202, 1. , -0.93657855,
-0.83571711],
[-0.934284 , -0.97074098, 0.89721355, -0.93657855, 1. ,
0.97517215],
[-0.99004057, -0.99981569, 0.77714685, -0.83571711, 0.97517215,
1. ]])

Finally if we use the option ``rowvar=False``, the columns are now

being treated as the variables and we will find the column-wise Pearson
correlation coefficients between variables in ``xarr`` and ``yarr``.

>>> R3 = np.corrcoef(xarr, yarr, rowvar=False)

>>> R3
array([[ 1. , 0.77598074, -0.47458546, -0.75078643, -0.9665554 ,
0.22423734],
[ 0.77598074, 1. , -0.92346708, -0.99923895, -0.58826587,
-0.44069024],
[-0.47458546, -0.92346708, 1. , 0.93773029, 0.23297648,
0.75137473],
[-0.75078643, -0.99923895, 0.93773029, 1. , 0.55627469,
0.47536961],
[-0.9665554 , -0.58826587, 0.23297648, 0.55627469, 1. ,
-0.46666491],
[ 0.22423734, -0.44069024, 0.75137473, 0.47536961, -0.46666491,
1. ]])

correlate(a, v, mode='valid')
Cross-correlation of two 1-dimensional sequences.

This function computes the correlation as generally defined in signal

processing texts:

.. math:: c_k = \sum_n a_{n+k} \cdot \overline{v}_n

with a and v sequences being zero-padded where necessary and

:math:`\overline x` denoting complex conjugation.

Parameters
----------
a, v : array_like
 Input sequences.
mode : {'valid', 'same', 'full'}, optional
Refer to the `convolve` docstring. Note that the default
is 'valid', unlike `convolve`, which uses 'full'.
old_behavior : bool
`old_behavior` was removed in NumPy 1.10. If you need the old
behavior, use `multiarray.correlate`.

Returns
-------
out : ndarray
Discrete cross-correlation of `a` and `v`.

See Also
--------
convolve : Discrete, linear convolution of two one-dimensional sequences.
multiarray.correlate : Old, no conjugate, version of correlate.
scipy.signal.correlate : uses FFT which has superior performance on large
arrays.

Notes
-----
The definition of correlation above is not unique and sometimes correlation
may be defined differently. Another common definition is:

.. math:: c'_k = \sum_n a_{n} \cdot \overline{v_{n+k}}

which is related to :math:`c_k` by :math:`c'_k = c_{-k}`.

`numpy.correlate` may perform slowly in large arrays (i.e. n = 1e5) because

it does
not use the FFT to compute the convolution; in that case,
`scipy.signal.correlate` might
be preferable.

Examples
--------
>>> np.correlate([1, 2, 3], [0, 1, 0.5])
array([3.5])
>>> np.correlate([1, 2, 3], [0, 1, 0.5], "same")
array([2. , 3.5, 3. ])
>>> np.correlate([1, 2, 3], [0, 1, 0.5], "full")
array([0.5, 2. , 3.5, 3. , 0. ])

Using complex sequences:

>>> np.correlate([1+1j, 2, 3-1j], [0, 1, 0.5j], 'full')

array([ 0.5-0.5j, 1.0+0.j , 1.5-1.5j, 3.0-1.j , 0.0+0.j ])

Note that you get the time reversed, complex conjugated result
(:math:`\overline{c_{-k}}`) when the two input sequences a and v change
places:

>>> np.correlate([0, 1, 0.5j], [1+1j, 2, 3-1j], 'full')

array([ 0.0+0.j , 3.0+1.j , 1.5+1.5j, 1.0+0.j , 0.5+0.5j])

count_nonzero(a, axis=None, *, keepdims=False)

Counts the number of non-zero values in the array ``a``.
 The word "non-zero" is in reference to the Python 2.x
built-in method ``__nonzero__()`` (renamed ``__bool__()``
in Python 3.x) of Python objects that tests an object's
"truthfulness". For example, any number is considered
truthful if it is nonzero, whereas any string is considered
truthful if it is not the empty string. Thus, this function
(recursively) counts how many elements in ``a`` (and in
sub-arrays thereof) have their ``__nonzero__()`` or ``__bool__()``
method evaluated to ``True``.

Parameters
----------
a : array_like
The array for which to count non-zeros.
axis : int or tuple, optional
Axis or tuple of axes along which to count non-zeros.
Default is None, meaning that non-zeros will be counted
along a flattened version of ``a``.

.. versionadded:: 1.12.0

keepdims : bool, optional

If this is set to True, the axes that are counted are left
in the result as dimensions with size one. With this option,
the result will broadcast correctly against the input array.

.. versionadded:: 1.19.0

Returns
-------
count : int or array of int
Number of non-zero values in the array along a given axis.
Otherwise, the total number of non-zero values in the array
is returned.

See Also
--------
nonzero : Return the coordinates of all the non-zero values.

Examples
--------
>>> np.count_nonzero(np.eye(4))
4
>>> a = np.array([[0, 1, 7, 0],
... [3, 0, 2, 19]])
>>> np.count_nonzero(a)
5
>>> np.count_nonzero(a, axis=0)
array([1, 1, 2, 1])
>>> np.count_nonzero(a, axis=1)
array([2, 3])
>>> np.count_nonzero(a, axis=1, keepdims=True)
array([[2],
[3]])

cov(m, y=None, rowvar=True, bias=False, ddof=None, fweights=None,

aweights=None, *, dtype=None)
Estimate a covariance matrix, given data and weights.
Covariance indicates the level to which two variables vary together.
If we examine N-dimensional samples, :math:`X = [x_1, x_2, ... x_N]^T`,
then the covariance matrix element :math:`C_{ij}` is the covariance of
:math:`x_i` and :math:`x_j`. The element :math:`C_{ii}` is the variance
of :math:`x_i`.

See the notes for an outline of the algorithm.

Parameters
----------
m : array_like
A 1-D or 2-D array containing multiple variables and observations.
Each row of `m` represents a variable, and each column a single
observation of all those variables. Also see `rowvar` below.
y : array_like, optional
An additional set of variables and observations. `y` has the same form
as that of `m`.
rowvar : bool, optional
If `rowvar` is True (default), then each row represents a
variable, with observations in the columns. Otherwise, the relationship
is transposed: each column represents a variable, while the rows
contain observations.
bias : bool, optional
Default normalization (False) is by ``(N - 1)``, where ``N`` is the
number of observations given (unbiased estimate). If `bias` is True,
then normalization is by ``N``. These values can be overridden by using
the keyword ``ddof`` in numpy versions >= 1.5.
ddof : int, optional
If not ``None`` the default value implied by `bias` is overridden.
Note that ``ddof=1`` will return the unbiased estimate, even if both
`fweights` and `aweights` are specified, and ``ddof=0`` will return
the simple average. See the notes for the details. The default value
is ``None``.

.. versionadded:: 1.5
fweights : array_like, int, optional
1-D array of integer frequency weights; the number of times each
observation vector should be repeated.

.. versionadded:: 1.10
aweights : array_like, optional
1-D array of observation vector weights. These relative weights are
typically large for observations considered "important" and smaller for
observations considered less "important". If ``ddof=0`` the array of
weights can be used to assign probabilities to observation vectors.

.. versionadded:: 1.10
dtype : data-type, optional
Data-type of the result. By default, the return data-type will have
at least `numpy.float64` precision.

.. versionadded:: 1.20

Returns
-------
out : ndarray
The covariance matrix of the variables.
 See Also
--------
corrcoef : Normalized covariance matrix

Notes
-----
Assume that the observations are in the columns of the observation
array `m` and let ``f = fweights`` and ``a = aweights`` for brevity. The
steps to compute the weighted covariance are as follows::

>>> m = np.arange(10, dtype=np.float64)

>>> f = np.arange(10) * 2
>>> a = np.arange(10) ** 2.
>>> ddof = 1
>>> w = f * a
>>> v1 = np.sum(w)
>>> v2 = np.sum(w * a)
>>> m -= np.sum(m * w, axis=None, keepdims=True) / v1
>>> cov = np.dot(m * w, m.T) * v1 / (v1**2 - ddof * v2)

Note that when ``a == 1``, the normalization factor

``v1 / (v1**2 - ddof * v2)`` goes over to ``1 / (np.sum(f) - ddof)``
as it should.

Examples
--------
Consider two variables, :math:`x_0` and :math:`x_1`, which
correlate perfectly, but in opposite directions:

>>> x = np.array([[0, 2], [1, 1], [2, 0]]).T

>>> x
array([[0, 1, 2],
[2, 1, 0]])

Note how :math:`x_0` increases while :math:`x_1` decreases. The covariance

matrix shows this clearly:

>>> np.cov(x)
array([[ 1., -1.],
[-1., 1.]])

Note that element :math:`C_{0,1}`, which shows the correlation between

:math:`x_0` and :math:`x_1`, is negative.

Further, note how `x` and `y` are combined:

>>> x = [-2.1, -1, 4.3]

>>> y = [3, 1.1, 0.12]
>>> X = np.stack((x, y), axis=0)
>>> np.cov(X)
array([[11.71 , -4.286 ], # may vary
[-4.286 , 2.144133]])
>>> np.cov(x, y)
array([[11.71 , -4.286 ], # may vary
[-4.286 , 2.144133]])
>>> np.cov(x)
array(11.71)

cross(a, b, axisa=-1, axisb=-1, axisc=-1, axis=None)

Return the cross product of two (arrays of) vectors.

The cross product of `a` and `b` in :math:`R^3` is a vector perpendicular

to both `a` and `b`. If `a` and `b` are arrays of vectors, the vectors
are defined by the last axis of `a` and `b` by default, and these axes
can have dimensions 2 or 3. Where the dimension of either `a` or `b` is
2, the third component of the input vector is assumed to be zero and the
cross product calculated accordingly. In cases where both input vectors
have dimension 2, the z-component of the cross product is returned.

Parameters
----------
a : array_like
Components of the first vector(s).
b : array_like
Components of the second vector(s).
axisa : int, optional
Axis of `a` that defines the vector(s). By default, the last axis.
axisb : int, optional
Axis of `b` that defines the vector(s). By default, the last axis.
axisc : int, optional
Axis of `c` containing the cross product vector(s). Ignored if
both input vectors have dimension 2, as the return is scalar.
By default, the last axis.
axis : int, optional
If defined, the axis of `a`, `b` and `c` that defines the vector(s)
and cross product(s). Overrides `axisa`, `axisb` and `axisc`.

Returns
-------
c : ndarray
Vector cross product(s).

Raises
------
ValueError
When the dimension of the vector(s) in `a` and/or `b` does not
equal 2 or 3.

See Also
--------
inner : Inner product
outer : Outer product.
ix_ : Construct index arrays.

Notes
-----
.. versionadded:: 1.9.0

Supports full broadcasting of the inputs.

Examples
--------
Vector cross-product.

>>> x = [1, 2, 3]
>>> y = [4, 5, 6]
>>> np.cross(x, y)
array([-3, 6, -3])
 One vector with dimension 2.

>>> x = [1, 2]
>>> y = [4, 5, 6]
>>> np.cross(x, y)
array([12, -6, -3])

Equivalently:

>>> x = [1, 2, 0]
>>> y = [4, 5, 6]
>>> np.cross(x, y)
array([12, -6, -3])

Both vectors with dimension 2.

>>> x = [1,2]
>>> y = [4,5]
>>> np.cross(x, y)
array(-3)

Multiple vector cross-products. Note that the direction of the cross

product vector is defined by the *right-hand rule*.

>>> x = np.array([[1,2,3], [4,5,6]])

>>> y = np.array([[4,5,6], [1,2,3]])
>>> np.cross(x, y)
array([[-3, 6, -3],
[ 3, -6, 3]])

The orientation of `c` can be changed using the `axisc` keyword.

>>> np.cross(x, y, axisc=0)

array([[-3, 3],
[ 6, -6],
[-3, 3]])

Change the vector definition of `x` and `y` using `axisa` and `axisb`.

>>> x = np.array([[1,2,3], [4,5,6], [7, 8, 9]])

>>> y = np.array([[7, 8, 9], [4,5,6], [1,2,3]])
>>> np.cross(x, y)
array([[ -6, 12, -6],
[ 0, 0, 0],
[ 6, -12, 6]])
>>> np.cross(x, y, axisa=0, axisb=0)
array([[-24, 48, -24],
[-30, 60, -30],
[-36, 72, -36]])

cumprod(a, axis=None, dtype=None, out=None)

Return the cumulative product of elements along a given axis.

Parameters
----------
a : array_like
Input array.
axis : int, optional
 Axis along which the cumulative product is computed. By default
the input is flattened.
dtype : dtype, optional
Type of the returned array, as well as of the accumulator in which
the elements are multiplied. If *dtype* is not specified, it
defaults to the dtype of `a`, unless `a` has an integer dtype with
a precision less than that of the default platform integer. In
that case, the default platform integer is used instead.
out : ndarray, optional
Alternative output array in which to place the result. It must
have the same shape and buffer length as the expected output
but the type of the resulting values will be cast if necessary.

Returns
-------
cumprod : ndarray
A new array holding the result is returned unless `out` is
specified, in which case a reference to out is returned.

See Also
--------
:ref:`ufuncs-output-type`

Notes
-----
Arithmetic is modular when using integer types, and no error is
raised on overflow.

Examples
--------
>>> a = np.array([1,2,3])
>>> np.cumprod(a) # intermediate results 1, 1*2
... # total product 1*2*3 = 6
array([1, 2, 6])
>>> a = np.array([[1, 2, 3], [4, 5, 6]])
>>> np.cumprod(a, dtype=float) # specify type of output
array([ 1., 2., 6., 24., 120., 720.])

The cumulative product for each column (i.e., over the rows) of `a`:

>>> np.cumprod(a, axis=0)

array([[ 1, 2, 3],
[ 4, 10, 18]])

The cumulative product for each row (i.e. over the columns) of `a`:

>>> np.cumprod(a,axis=1)
array([[ 1, 2, 6],
[ 4, 20, 120]])

cumproduct(*args, **kwargs)
Return the cumulative product over the given axis.

.. deprecated:: 1.25.0
``cumproduct`` is deprecated as of NumPy 1.25.0, and will be
removed in NumPy 2.0. Please use `cumprod` instead.

See Also
--------
 cumprod : equivalent function; see for details.

cumsum(a, axis=None, dtype=None, out=None)

Return the cumulative sum of the elements along a given axis.

Parameters
----------
a : array_like
Input array.
axis : int, optional
Axis along which the cumulative sum is computed. The default
(None) is to compute the cumsum over the flattened array.
dtype : dtype, optional
Type of the returned array and of the accumulator in which the
elements are summed. If `dtype` is not specified, it defaults
to the dtype of `a`, unless `a` has an integer dtype with a
precision less than that of the default platform integer. In
that case, the default platform integer is used.
out : ndarray, optional
Alternative output array in which to place the result. It must
have the same shape and buffer length as the expected output
but the type will be cast if necessary. See :ref:`ufuncs-output-type`
for
more details.

Returns
-------
cumsum_along_axis : ndarray.
A new array holding the result is returned unless `out` is
specified, in which case a reference to `out` is returned. The
result has the same size as `a`, and the same shape as `a` if
`axis` is not None or `a` is a 1-d array.

See Also
--------
sum : Sum array elements.
trapz : Integration of array values using the composite trapezoidal rule.
diff : Calculate the n-th discrete difference along given axis.

Notes
-----
Arithmetic is modular when using integer types, and no error is
raised on overflow.

``cumsum(a)[-1]`` may not be equal to ``sum(a)`` for floating-point

values since ``sum`` may use a pairwise summation routine, reducing
the roundoff-error. See `sum` for more information.

Examples
--------
>>> a = np.array([[1,2,3], [4,5,6]])
>>> a
array([[1, 2, 3],
[4, 5, 6]])
>>> np.cumsum(a)
array([ 1, 3, 6, 10, 15, 21])
>>> np.cumsum(a, dtype=float) # specifies type of output value(s)
array([ 1., 3., 6., 10., 15., 21.])
 >>> np.cumsum(a,axis=0) # sum over rows for each of the 3 columns
array([[1, 2, 3],
[5, 7, 9]])
>>> np.cumsum(a,axis=1) # sum over columns for each of the 2 rows
array([[ 1, 3, 6],
[ 4, 9, 15]])

``cumsum(b)[-1]`` may not be equal to ``sum(b)``

>>> b = np.array([1, 2e-9, 3e-9] * 1000000)

>>> b.cumsum()[-1]
1000000.0050045159
>>> b.sum()
1000000.0050000029

datetime_as_string(...)
datetime_as_string(arr, unit=None, timezone='naive', casting='same_kind')

Convert an array of datetimes into an array of strings.

Parameters
----------
arr : array_like of datetime64
The array of UTC timestamps to format.
unit : str
One of None, 'auto', or a :ref:`datetime unit
<arrays.dtypes.dateunits>`.
timezone : {'naive', 'UTC', 'local'} or tzinfo
Timezone information to use when displaying the datetime. If 'UTC', end
with a Z to indicate UTC time. If 'local', convert to the local
timezone
first, and suffix with a +-#### timezone offset. If a tzinfo object,
then do as with 'local', but use the specified timezone.
casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}
Casting to allow when changing between datetime units.

Returns
-------
str_arr : ndarray
An array of strings the same shape as `arr`.

Examples
--------
>>> import pytz
>>> d = np.arange('2002-10-27T04:30', 4*60, 60, dtype='M8[m]')
>>> d
array(['2002-10-27T04:30', '2002-10-27T05:30', '2002-10-27T06:30',
'2002-10-27T07:30'], dtype='datetime64[m]')

Setting the timezone to UTC shows the same information, but with a Z suffix

>>> np.datetime_as_string(d, timezone='UTC')

array(['2002-10-27T04:30Z', '2002-10-27T05:30Z', '2002-10-27T06:30Z',
'2002-10-27T07:30Z'], dtype='<U35')

Note that we picked datetimes that cross a DST boundary. Passing in a

``pytz`` timezone object will print the appropriate offset

>>> np.datetime_as_string(d, timezone=pytz.timezone('US/Eastern'))

 array(['2002-10-27T00:30-0400', '2002-10-27T01:30-0400',
'2002-10-27T01:30-0500', '2002-10-27T02:30-0500'], dtype='<U39')

Passing in a unit will change the precision

>>> np.datetime_as_string(d, unit='h')

array(['2002-10-27T04', '2002-10-27T05', '2002-10-27T06', '2002-10-27T07'],
dtype='<U32')
>>> np.datetime_as_string(d, unit='s')
array(['2002-10-27T04:30:00', '2002-10-27T05:30:00', '2002-10-27T06:30:00',
'2002-10-27T07:30:00'], dtype='<U38')

'casting' can be used to specify whether precision can be changed

>>> np.datetime_as_string(d, unit='h', casting='safe')

Traceback (most recent call last):
...
TypeError: Cannot create a datetime string as units 'h' from a NumPy
datetime with units 'm' according to the rule 'safe'

datetime_data(...)
datetime_data(dtype, /)

Get information about the step size of a date or time type.

The returned tuple can be passed as the second argument of

`numpy.datetime64` and
`numpy.timedelta64`.

Parameters
----------
dtype : dtype
The dtype object, which must be a `datetime64` or `timedelta64` type.

Returns
-------
unit : str
The :ref:`datetime unit <arrays.dtypes.dateunits>` on which this dtype
is based.
count : int
The number of base units in a step.

Examples
--------
>>> dt_25s = np.dtype('timedelta64[25s]')
>>> np.datetime_data(dt_25s)
('s', 25)
>>> np.array(10, dt_25s).astype('timedelta64[s]')
array(250, dtype='timedelta64[s]')

The result can be used to construct a datetime that uses the same units
as a timedelta

>>> np.datetime64('2010', np.datetime_data(dt_25s))

numpy.datetime64('2010-01-01T00:00:00','25s')

delete(arr, obj, axis=None)

Return a new array with sub-arrays along an axis deleted. For a one
dimensional array, this returns those entries not returned by
`arr[obj]`.

Parameters
----------
arr : array_like
Input array.
obj : slice, int or array of ints
Indicate indices of sub-arrays to remove along the specified axis.

.. versionchanged:: 1.19.0
Boolean indices are now treated as a mask of elements to remove,
rather than being cast to the integers 0 and 1.

axis : int, optional

The axis along which to delete the subarray defined by `obj`.
If `axis` is None, `obj` is applied to the flattened array.

Returns
-------
out : ndarray
A copy of `arr` with the elements specified by `obj` removed. Note
that `delete` does not occur in-place. If `axis` is None, `out` is
a flattened array.

See Also
--------
insert : Insert elements into an array.
append : Append elements at the end of an array.

Notes
-----
Often it is preferable to use a boolean mask. For example:

>>> arr = np.arange(12) + 1

>>> mask = np.ones(len(arr), dtype=bool)
>>> mask[[0,2,4]] = False
>>> result = arr[mask,...]

Is equivalent to ``np.delete(arr, [0,2,4], axis=0)``, but allows further

use of `mask`.

Examples
--------
>>> arr = np.array([[1,2,3,4], [5,6,7,8], [9,10,11,12]])
>>> arr
array([[ 1, 2, 3, 4],
[ 5, 6, 7, 8],
[ 9, 10, 11, 12]])
>>> np.delete(arr, 1, 0)
array([[ 1, 2, 3, 4],
[ 9, 10, 11, 12]])

>>> np.delete(arr, np.s_[::2], 1)

array([[ 2, 4],
[ 6, 8],
[10, 12]])
>>> np.delete(arr, [1,3,5], None)
array([ 1, 3, 5, 7, 8, 9, 10, 11, 12])
deprecate(*args, **kwargs)
Issues a DeprecationWarning, adds warning to `old_name`'s
docstring, rebinds ``old_name.__name__`` and returns the new
function object.

This function may also be used as a decorator.

Parameters
----------
func : function
The function to be deprecated.
old_name : str, optional
The name of the function to be deprecated. Default is None, in
which case the name of `func` is used.
new_name : str, optional
The new name for the function. Default is None, in which case the
deprecation message is that `old_name` is deprecated. If given, the
deprecation message is that `old_name` is deprecated and `new_name`
should be used instead.
message : str, optional
Additional explanation of the deprecation. Displayed in the
docstring after the warning.

Returns
-------
old_func : function
The deprecated function.

Examples
--------
Note that ``olduint`` returns a value after printing Deprecation
Warning:

>>> olduint = np.deprecate(np.uint)

DeprecationWarning: `uint64` is deprecated! # may vary
>>> olduint(6)
6

deprecate_with_doc(msg)
Deprecates a function and includes the deprecation in its docstring.

This function is used as a decorator. It returns an object that can be

used to issue a DeprecationWarning, by passing the to-be decorated
function as argument, this adds warning to the to-be decorated function's
docstring and returns the new function object.

See Also
--------
deprecate : Decorate a function such that it issues a `DeprecationWarning`

Parameters
----------
msg : str
Additional explanation of the deprecation. Displayed in the
docstring after the warning.

Returns
-------
obj : object
diag(v, k=0)
Extract a diagonal or construct a diagonal array.

See the more detailed documentation for ``numpy.diagonal`` if you use this
function to extract a diagonal and wish to write to the resulting array;
whether it returns a copy or a view depends on what version of numpy you
are using.

Parameters
----------
v : array_like
If `v` is a 2-D array, return a copy of its `k`-th diagonal.
If `v` is a 1-D array, return a 2-D array with `v` on the `k`-th
diagonal.
k : int, optional
Diagonal in question. The default is 0. Use `k>0` for diagonals
above the main diagonal, and `k<0` for diagonals below the main
diagonal.

Returns
-------
out : ndarray
The extracted diagonal or constructed diagonal array.

See Also
--------
diagonal : Return specified diagonals.
diagflat : Create a 2-D array with the flattened input as a diagonal.
trace : Sum along diagonals.
triu : Upper triangle of an array.
tril : Lower triangle of an array.

Examples
--------
>>> x = np.arange(9).reshape((3,3))
>>> x
array([[0, 1, 2],
[3, 4, 5],
[6, 7, 8]])

>>> np.diag(x)
array([0, 4, 8])
>>> np.diag(x, k=1)
array([1, 5])
>>> np.diag(x, k=-1)
array([3, 7])

>>> np.diag(np.diag(x))
array([[0, 0, 0],
[0, 4, 0],
[0, 0, 8]])

diag_indices(n, ndim=2)
Return the indices to access the main diagonal of an array.

This returns a tuple of indices that can be used to access the main
diagonal of an array `a` with ``a.ndim >= 2`` dimensions and shape
(n, n, ..., n). For ``a.ndim = 2`` this is the usual diagonal, for
 ``a.ndim > 2`` this is the set of indices to access ``a[i, i, ..., i]``
for ``i = [0..n-1]``.

Parameters
----------
n : int
The size, along each dimension, of the arrays for which the returned
indices can be used.

ndim : int, optional

The number of dimensions.

See Also
--------
diag_indices_from

Notes
-----
.. versionadded:: 1.4.0

Examples
--------
Create a set of indices to access the diagonal of a (4, 4) array:

>>> di = np.diag_indices(4)
>>> di
(array([0, 1, 2, 3]), array([0, 1, 2, 3]))
>>> a = np.arange(16).reshape(4, 4)
>>> a
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11],
[12, 13, 14, 15]])
>>> a[di] = 100
>>> a
array([[100, 1, 2, 3],
[ 4, 100, 6, 7],
[ 8, 9, 100, 11],
[ 12, 13, 14, 100]])

Now, we create indices to manipulate a 3-D array:

>>> d3 = np.diag_indices(2, 3)
>>> d3
(array([0, 1]), array([0, 1]), array([0, 1]))

And use it to set the diagonal of an array of zeros to 1:

>>> a = np.zeros((2, 2, 2), dtype=int)

>>> a[d3] = 1
>>> a
array([[[1, 0],
[0, 0]],
[[0, 0],
[0, 1]]])

diag_indices_from(arr)
Return the indices to access the main diagonal of an n-dimensional array.
 See `diag_indices` for full details.

Parameters
----------
arr : array, at least 2-D

See Also
--------
diag_indices

Notes
-----
.. versionadded:: 1.4.0

Examples
--------

Create a 4 by 4 array.

>>> a = np.arange(16).reshape(4, 4)
>>> a
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11],
[12, 13, 14, 15]])

Get the indices of the diagonal elements.

>>> di = np.diag_indices_from(a)
>>> di
(array([0, 1, 2, 3]), array([0, 1, 2, 3]))

>>> a[di]
array([ 0, 5, 10, 15])

This is simply syntactic sugar for diag_indices.

>>> np.diag_indices(a.shape[0])
(array([0, 1, 2, 3]), array([0, 1, 2, 3]))

diagflat(v, k=0)
Create a two-dimensional array with the flattened input as a diagonal.

Parameters
----------
v : array_like
Input data, which is flattened and set as the `k`-th
diagonal of the output.
k : int, optional
Diagonal to set; 0, the default, corresponds to the "main" diagonal,
a positive (negative) `k` giving the number of the diagonal above
(below) the main.

Returns
-------
out : ndarray
The 2-D output array.

See Also
 --------
diag : MATLAB work-alike for 1-D and 2-D arrays.
diagonal : Return specified diagonals.
trace : Sum along diagonals.

Examples
--------
>>> np.diagflat([[1,2], [3,4]])
array([[1, 0, 0, 0],
[0, 2, 0, 0],
[0, 0, 3, 0],
[0, 0, 0, 4]])

>>> np.diagflat([1,2], 1)
array([[0, 1, 0],
[0, 0, 2],
[0, 0, 0]])

diagonal(a, offset=0, axis1=0, axis2=1)

Return specified diagonals.

If `a` is 2-D, returns the diagonal of `a` with the given offset,
i.e., the collection of elements of the form ``a[i, i+offset]``. If
`a` has more than two dimensions, then the axes specified by `axis1`
and `axis2` are used to determine the 2-D sub-array whose diagonal is
returned. The shape of the resulting array can be determined by
removing `axis1` and `axis2` and appending an index to the right equal
to the size of the resulting diagonals.

In versions of NumPy prior to 1.7, this function always returned a new,

independent array containing a copy of the values in the diagonal.

In NumPy 1.7 and 1.8, it continues to return a copy of the diagonal,

but depending on this fact is deprecated. Writing to the resulting
array continues to work as it used to, but a FutureWarning is issued.

Starting in NumPy 1.9 it returns a read-only view on the original array.

Attempting to write to the resulting array will produce an error.

In some future release, it will return a read/write view and writing to

the returned array will alter your original array. The returned array
will have the same type as the input array.

If you don't write to the array returned by this function, then you can
just ignore all of the above.

If you depend on the current behavior, then we suggest copying the

returned array explicitly, i.e., use ``np.diagonal(a).copy()`` instead
of just ``np.diagonal(a)``. This will work with both past and future
versions of NumPy.

Parameters
----------
a : array_like
Array from which the diagonals are taken.
offset : int, optional
Offset of the diagonal from the main diagonal. Can be positive or
negative. Defaults to main diagonal (0).
axis1 : int, optional
 Axis to be used as the first axis of the 2-D sub-arrays from which
the diagonals should be taken. Defaults to first axis (0).
axis2 : int, optional
Axis to be used as the second axis of the 2-D sub-arrays from
which the diagonals should be taken. Defaults to second axis (1).

Returns
-------
array_of_diagonals : ndarray
If `a` is 2-D, then a 1-D array containing the diagonal and of the
same type as `a` is returned unless `a` is a `matrix`, in which case
a 1-D array rather than a (2-D) `matrix` is returned in order to
maintain backward compatibility.

If ``a.ndim > 2``, then the dimensions specified by `axis1` and `axis2`
are removed, and a new axis inserted at the end corresponding to the
diagonal.

Raises
------
ValueError
If the dimension of `a` is less than 2.

See Also
--------
diag : MATLAB work-a-like for 1-D and 2-D arrays.
diagflat : Create diagonal arrays.
trace : Sum along diagonals.

Examples
--------
>>> a = np.arange(4).reshape(2,2)
>>> a
array([[0, 1],
[2, 3]])
>>> a.diagonal()
array([0, 3])
>>> a.diagonal(1)
array([1])

A 3-D example:

>>> a = np.arange(8).reshape(2,2,2); a
array([[[0, 1],
[2, 3]],
[[4, 5],
[6, 7]]])
>>> a.diagonal(0, # Main diagonals of two arrays created by skipping
... 0, # across the outer(left)-most axis last and
... 1) # the "middle" (row) axis first.
array([[0, 6],
[1, 7]])

The sub-arrays whose main diagonals we just obtained; note that each
corresponds to fixing the right-most (column) axis, and that the
diagonals are "packed" in rows.

>>> a[:,:,0] # main diagonal is [0 6]

array([[0, 2],
 [4, 6]])
>>> a[:,:,1] # main diagonal is [1 7]
array([[1, 3],
[5, 7]])

The anti-diagonal can be obtained by reversing the order of elements

using either `numpy.flipud` or `numpy.fliplr`.

>>> a = np.arange(9).reshape(3, 3)
>>> a
array([[0, 1, 2],
[3, 4, 5],
[6, 7, 8]])
>>> np.fliplr(a).diagonal() # Horizontal flip
array([2, 4, 6])
>>> np.flipud(a).diagonal() # Vertical flip
array([6, 4, 2])

Note that the order in which the diagonal is retrieved varies depending
on the flip function.

diff(a, n=1, axis=-1, prepend=<no value>, append=<no value>)

Calculate the n-th discrete difference along the given axis.

The first difference is given by ``out[i] = a[i+1] - a[i]`` along

the given axis, higher differences are calculated by using `diff`
recursively.

Parameters
----------
a : array_like
Input array
n : int, optional
The number of times values are differenced. If zero, the input
is returned as-is.
axis : int, optional
The axis along which the difference is taken, default is the
last axis.
prepend, append : array_like, optional
Values to prepend or append to `a` along axis prior to
performing the difference. Scalar values are expanded to
arrays with length 1 in the direction of axis and the shape
of the input array in along all other axes. Otherwise the
dimension and shape must match `a` except along axis.

.. versionadded:: 1.16.0

Returns
-------
diff : ndarray
The n-th differences. The shape of the output is the same as `a`
except along `axis` where the dimension is smaller by `n`. The
type of the output is the same as the type of the difference
between any two elements of `a`. This is the same as the type of
`a` in most cases. A notable exception is `datetime64`, which
results in a `timedelta64` output array.

See Also
--------
 gradient, ediff1d, cumsum

Notes
-----
Type is preserved for boolean arrays, so the result will contain
`False` when consecutive elements are the same and `True` when they
differ.

For unsigned integer arrays, the results will also be unsigned. This
should not be surprising, as the result is consistent with
calculating the difference directly:

>>> u8_arr = np.array([1, 0], dtype=np.uint8)

>>> np.diff(u8_arr)
array([255], dtype=uint8)
>>> u8_arr[1,...] - u8_arr[0,...]
255

If this is not desirable, then the array should be cast to a larger

integer type first:

>>> i16_arr = u8_arr.astype(np.int16)

>>> np.diff(i16_arr)
array([-1], dtype=int16)

Examples
--------
>>> x = np.array([1, 2, 4, 7, 0])
>>> np.diff(x)
array([ 1, 2, 3, -7])
>>> np.diff(x, n=2)
array([ 1, 1, -10])

>>> x = np.array([[1, 3, 6, 10], [0, 5, 6, 8]])

>>> np.diff(x)
array([[2, 3, 4],
[5, 1, 2]])
>>> np.diff(x, axis=0)
array([[-1, 2, 0, -2]])

>>> x = np.arange('1066-10-13', '1066-10-16', dtype=np.datetime64)

>>> np.diff(x)
array([1, 1], dtype='timedelta64[D]')

digitize(x, bins, right=False)

Return the indices of the bins to which each value in input array belongs.

========= ============= ============================

`right` order of bins returned index `i` satisfies
========= ============= ============================
``False`` increasing ``bins[i-1] <= x < bins[i]``
``True`` increasing ``bins[i-1] < x <= bins[i]``
``False`` decreasing ``bins[i-1] > x >= bins[i]``
``True`` decreasing ``bins[i-1] >= x > bins[i]``
========= ============= ============================

If values in `x` are beyond the bounds of `bins`, 0 or ``len(bins)`` is

returned as appropriate.
Parameters
----------
x : array_like
Input array to be binned. Prior to NumPy 1.10.0, this array had to
be 1-dimensional, but can now have any shape.
bins : array_like
Array of bins. It has to be 1-dimensional and monotonic.
right : bool, optional
Indicating whether the intervals include the right or the left bin
edge. Default behavior is (right==False) indicating that the interval
does not include the right edge. The left bin end is open in this
case, i.e., bins[i-1] <= x < bins[i] is the default behavior for
monotonically increasing bins.

Returns
-------
indices : ndarray of ints
Output array of indices, of same shape as `x`.

Raises
------
ValueError
If `bins` is not monotonic.
TypeError
If the type of the input is complex.

See Also
--------
bincount, histogram, unique, searchsorted

Notes
-----
If values in `x` are such that they fall outside the bin range,
attempting to index `bins` with the indices that `digitize` returns
will result in an IndexError.

.. versionadded:: 1.10.0

`np.digitize` is implemented in terms of `np.searchsorted`. This means

that a binary search is used to bin the values, which scales much better
for larger number of bins than the previous linear search. It also removes
the requirement for the input array to be 1-dimensional.

For monotonically _increasing_ `bins`, the following are equivalent::

np.digitize(x, bins, right=True)

np.searchsorted(bins, x, side='left')

Note that as the order of the arguments are reversed, the side must be too.
The `searchsorted` call is marginally faster, as it does not do any
monotonicity checks. Perhaps more importantly, it supports all dtypes.

Examples
--------
>>> x = np.array([0.2, 6.4, 3.0, 1.6])
>>> bins = np.array([0.0, 1.0, 2.5, 4.0, 10.0])
>>> inds = np.digitize(x, bins)
>>> inds
array([1, 4, 3, 2])
 >>> for n in range(x.size):
... print(bins[inds[n]-1], "<=", x[n], "<", bins[inds[n]])
...
0.0 <= 0.2 < 1.0
4.0 <= 6.4 < 10.0
2.5 <= 3.0 < 4.0
1.0 <= 1.6 < 2.5

>>> x = np.array([1.2, 10.0, 12.4, 15.5, 20.])

>>> bins = np.array([0, 5, 10, 15, 20])
>>> np.digitize(x,bins,right=True)
array([1, 2, 3, 4, 4])
>>> np.digitize(x,bins,right=False)
array([1, 3, 3, 4, 5])

disp(mesg, device=None, linefeed=True)

Display a message on a device.

Parameters
----------
mesg : str
Message to display.
device : object
Device to write message. If None, defaults to ``sys.stdout`` which is
very similar to ``print``. `device` needs to have ``write()`` and
``flush()`` methods.
linefeed : bool, optional
Option whether to print a line feed or not. Defaults to True.

Raises
------
AttributeError
If `device` does not have a ``write()`` or ``flush()`` method.

Examples
--------
Besides ``sys.stdout``, a file-like object can also be used as it has
both required methods:

>>> from io import StringIO

>>> buf = StringIO()
>>> np.disp(u'"Display" in a file', device=buf)
>>> buf.getvalue()
'"Display" in a file\n'

dot(...)
dot(a, b, out=None)

Dot product of two arrays. Specifically,

- If both `a` and `b` are 1-D arrays, it is inner product of vectors
(without complex conjugation).

- If both `a` and `b` are 2-D arrays, it is matrix multiplication,

but using :func:`matmul` or ``a @ b`` is preferred.

- If either `a` or `b` is 0-D (scalar), it is equivalent to

:func:`multiply` and using ``numpy.multiply(a, b)`` or ``a * b`` is
preferred.
- If `a` is an N-D array and `b` is a 1-D array, it is a sum product over
the last axis of `a` and `b`.

- If `a` is an N-D array and `b` is an M-D array (where ``M>=2``), it is a

sum product over the last axis of `a` and the second-to-last axis of
`b`::

dot(a, b)[i,j,k,m] = sum(a[i,j,:] * b[k,:,m])

It uses an optimized BLAS library when possible (see `numpy.linalg`).

Parameters
----------
a : array_like
First argument.
b : array_like
Second argument.
out : ndarray, optional
Output argument. This must have the exact kind that would be returned
if it was not used. In particular, it must have the right type, must be
C-contiguous, and its dtype must be the dtype that would be returned
for `dot(a,b)`. This is a performance feature. Therefore, if these
conditions are not met, an exception is raised, instead of attempting
to be flexible.

Returns
-------
output : ndarray
Returns the dot product of `a` and `b`. If `a` and `b` are both
scalars or both 1-D arrays then a scalar is returned; otherwise
an array is returned.
If `out` is given, then it is returned.

Raises
------
ValueError
If the last dimension of `a` is not the same size as
the second-to-last dimension of `b`.

See Also
--------
vdot : Complex-conjugating dot product.
tensordot : Sum products over arbitrary axes.
einsum : Einstein summation convention.
matmul : '@' operator as method with out parameter.
linalg.multi_dot : Chained dot product.

Examples
--------
>>> np.dot(3, 4)
12

Neither argument is complex-conjugated:

>>> np.dot([2j, 3j], [2j, 3j])

(-13+0j)

For 2-D arrays it is the matrix product:

 >>> a = [[1, 0], [0, 1]]
>>> b = [[4, 1], [2, 2]]
>>> np.dot(a, b)
array([[4, 1],
[2, 2]])

>>> a = np.arange(3*4*5*6).reshape((3,4,5,6))
>>> b = np.arange(3*4*5*6)[::-1].reshape((5,4,6,3))
>>> np.dot(a, b)[2,3,2,1,2,2]
499128
>>> sum(a[2,3,2,:] * b[1,2,:,2])
499128

dsplit(ary, indices_or_sections)
Split array into multiple sub-arrays along the 3rd axis (depth).

Please refer to the `split` documentation. `dsplit` is equivalent

to `split` with ``axis=2``, the array is always split along the third
axis provided the array dimension is greater than or equal to 3.

See Also
--------
split : Split an array into multiple sub-arrays of equal size.

Examples
--------
>>> x = np.arange(16.0).reshape(2, 2, 4)
>>> x
array([[[ 0., 1., 2., 3.],
[ 4., 5., 6., 7.]],
[[ 8., 9., 10., 11.],
[12., 13., 14., 15.]]])
>>> np.dsplit(x, 2)
[array([[[ 0., 1.],
[ 4., 5.]],
[[ 8., 9.],
[12., 13.]]]), array([[[ 2., 3.],
[ 6., 7.]],
[[10., 11.],
[14., 15.]]])]
>>> np.dsplit(x, np.array([3, 6]))
[array([[[ 0., 1., 2.],
[ 4., 5., 6.]],
[[ 8., 9., 10.],
[12., 13., 14.]]]),
array([[[ 3.],
[ 7.]],
[[11.],
[15.]]]),
array([], shape=(2, 2, 0), dtype=float64)]

dstack(tup)
Stack arrays in sequence depth wise (along third axis).

This is equivalent to concatenation along the third axis after 2-D arrays
of shape `(M,N)` have been reshaped to `(M,N,1)` and 1-D arrays of shape
`(N,)` have been reshaped to `(1,N,1)`. Rebuilds arrays divided by
`dsplit`.
 This function makes most sense for arrays with up to 3 dimensions. For
instance, for pixel-data with a height (first axis), width (second axis),
and r/g/b channels (third axis). The functions `concatenate`, `stack` and
`block` provide more general stacking and concatenation operations.

Parameters
----------
tup : sequence of arrays
The arrays must have the same shape along all but the third axis.
1-D or 2-D arrays must have the same shape.

Returns
-------
stacked : ndarray
The array formed by stacking the given arrays, will be at least 3-D.

See Also
--------
concatenate : Join a sequence of arrays along an existing axis.
stack : Join a sequence of arrays along a new axis.
block : Assemble an nd-array from nested lists of blocks.
vstack : Stack arrays in sequence vertically (row wise).
hstack : Stack arrays in sequence horizontally (column wise).
column_stack : Stack 1-D arrays as columns into a 2-D array.
dsplit : Split array along third axis.

Examples
--------
>>> a = np.array((1,2,3))
>>> b = np.array((2,3,4))
>>> np.dstack((a,b))
array([[[1, 2],
[2, 3],
[3, 4]]])

>>> a = np.array([[1],[2],[3]])
>>> b = np.array([[2],[3],[4]])
>>> np.dstack((a,b))
array([[[1, 2]],
[[2, 3]],
[[3, 4]]])

ediff1d(ary, to_end=None, to_begin=None)

The differences between consecutive elements of an array.

Parameters
----------
ary : array_like
If necessary, will be flattened before the differences are taken.
to_end : array_like, optional
Number(s) to append at the end of the returned differences.
to_begin : array_like, optional
Number(s) to prepend at the beginning of the returned differences.

Returns
-------
ediff1d : ndarray
The differences. Loosely, this is ``ary.flat[1:] - ary.flat[:-1]``.
 See Also
--------
diff, gradient

Notes
-----
When applied to masked arrays, this function drops the mask information
if the `to_begin` and/or `to_end` parameters are used.

Examples
--------
>>> x = np.array([1, 2, 4, 7, 0])
>>> np.ediff1d(x)
array([ 1, 2, 3, -7])

>>> np.ediff1d(x, to_begin=-99, to_end=np.array([88, 99]))

array([-99, 1, 2, ..., -7, 88, 99])

The returned array is always 1D.

>>> y = [[1, 2, 4], [1, 6, 24]]

>>> np.ediff1d(y)
array([ 1, 2, -3, 5, 18])

einsum(*operands, out=None, optimize=False, **kwargs)

einsum(subscripts, *operands, out=None, dtype=None, order='K',
casting='safe', optimize=False)

Evaluates the Einstein summation convention on the operands.

Using the Einstein summation convention, many common multi-dimensional,

linear algebraic array operations can be represented in a simple fashion.
In *implicit* mode `einsum` computes these values.

In *explicit* mode, `einsum` provides further flexibility to compute

other array operations that might not be considered classical Einstein
summation operations, by disabling, or forcing summation over specified
subscript labels.

See the notes and examples for clarification.

Parameters
----------
subscripts : str
Specifies the subscripts for summation as comma separated list of
subscript labels. An implicit (classical Einstein summation)
calculation is performed unless the explicit indicator '->' is
included as well as subscript labels of the precise output form.
operands : list of array_like
These are the arrays for the operation.
out : ndarray, optional
If provided, the calculation is done into this array.
dtype : {data-type, None}, optional
If provided, forces the calculation to use the data type specified.
Note that you may have to also give a more liberal `casting`
parameter to allow the conversions. Default is None.
order : {'C', 'F', 'A', 'K'}, optional
Controls the memory layout of the output. 'C' means it should
 be C contiguous. 'F' means it should be Fortran contiguous,
'A' means it should be 'F' if the inputs are all 'F', 'C' otherwise.
'K' means it should be as close to the layout as the inputs as
is possible, including arbitrarily permuted axes.
Default is 'K'.
casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
Controls what kind of data casting may occur. 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.

Default is 'safe'.
optimize : {False, True, 'greedy', 'optimal'}, optional
Controls if intermediate optimization should occur. No optimization
will occur if False and True will default to the 'greedy' algorithm.
Also accepts an explicit contraction list from the ``np.einsum_path``
function. See ``np.einsum_path`` for more details. Defaults to False.

Returns
-------
output : ndarray
The calculation based on the Einstein summation convention.

See Also
--------
einsum_path, dot, inner, outer, tensordot, linalg.multi_dot
einops :
similar verbose interface is provided by
`einops <https://github.com/arogozhnikov/einops>`_ package to cover
additional operations: transpose, reshape/flatten, repeat/tile,
squeeze/unsqueeze and reductions.
opt_einsum :
`opt_einsum <https://optimized-einsum.readthedocs.io/en/stable/>`_
optimizes contraction order for einsum-like expressions
in backend-agnostic manner.

Notes
-----
.. versionadded:: 1.6.0

The Einstein summation convention can be used to compute

many multi-dimensional, linear algebraic array operations. `einsum`
provides a succinct way of representing these.

A non-exhaustive list of these operations,

which can be computed by `einsum`, is shown below along with examples:

* Trace of an array, :py:func:`numpy.trace`.

* Return a diagonal, :py:func:`numpy.diag`.
* Array axis summations, :py:func:`numpy.sum`.
* Transpositions and permutations, :py:func:`numpy.transpose`.
* Matrix multiplication and dot
product, :py:func:`numpy.matmul` :py:func:`numpy.dot`.
* Vector inner and outer
products, :py:func:`numpy.inner` :py:func:`numpy.outer`.
* Broadcasting, element-wise and scalar
multiplication, :py:func:`numpy.multiply`.
* Tensor contractions, :py:func:`numpy.tensordot`.
* Chained array operations, in efficient calculation
order, :py:func:`numpy.einsum_path`.

The subscripts string is a comma-separated list of subscript labels,

where each label refers to a dimension of the corresponding operand.
Whenever a label is repeated it is summed, so ``np.einsum('i,i', a, b)``
is equivalent to :py:func:`np.inner(a,b) <numpy.inner>`. If a label
appears only once, it is not summed, so ``np.einsum('i', a)`` produces a
view of ``a`` with no changes. A further example ``np.einsum('ij,jk', a,
b)``
describes traditional matrix multiplication and is equivalent to
:py:func:`np.matmul(a,b) <numpy.matmul>`. Repeated subscript labels in one
operand take the diagonal. For example, ``np.einsum('ii', a)`` is
equivalent
to :py:func:`np.trace(a) <numpy.trace>`.

In *implicit mode*, the chosen subscripts are important

since the axes of the output are reordered alphabetically. This
means that ``np.einsum('ij', a)`` doesn't affect a 2D array, while
``np.einsum('ji', a)`` takes its transpose. Additionally,
``np.einsum('ij,jk', a, b)`` returns a matrix multiplication, while,
``np.einsum('ij,jh', a, b)`` returns the transpose of the
multiplication since subscript 'h' precedes subscript 'i'.

In *explicit mode* the output can be directly controlled by

specifying output subscript labels. This requires the
identifier '->' as well as the list of output subscript labels.
This feature increases the flexibility of the function since
summing can be disabled or forced when required. The call
``np.einsum('i->', a)`` is like :py:func:`np.sum(a, axis=-1) <numpy.sum>`,
and ``np.einsum('ii->i', a)`` is like :py:func:`np.diag(a) <numpy.diag>`.
The difference is that `einsum` does not allow broadcasting by default.
Additionally ``np.einsum('ij,jh->ih', a, b)`` directly specifies the
order of the output subscript labels and therefore returns matrix
multiplication, unlike the example above in implicit mode.

To enable and control broadcasting, use an ellipsis. Default

NumPy-style broadcasting is done by adding an ellipsis
to the left of each term, like ``np.einsum('...ii->...i', a)``.
To take the trace along the first and last axes,
you can do ``np.einsum('i...i', a)``, or to do a matrix-matrix
product with the left-most indices instead of rightmost, one can do
``np.einsum('ij...,jk...->ik...', a, b)``.

When there is only one operand, no axes are summed, and no output
parameter is provided, a view into the operand is returned instead
of a new array. Thus, taking the diagonal as ``np.einsum('ii->i', a)``
produces a view (changed in version 1.10.0).

`einsum` also provides an alternative way to provide the subscripts

and operands as ``einsum(op0, sublist0, op1, sublist1, ...,
[sublistout])``.
If the output shape is not provided in this format `einsum` will be
calculated in implicit mode, otherwise it will be performed explicitly.
The examples below have corresponding `einsum` calls with the two
 parameter methods.

.. versionadded:: 1.10.0

Views returned from einsum are now writeable whenever the input array
is writeable. For example, ``np.einsum('ijk...->kji...', a)`` will now
have the same effect as :py:func:`np.swapaxes(a, 0, 2) <numpy.swapaxes>`
and ``np.einsum('ii->i', a)`` will return a writeable view of the diagonal
of a 2D array.

.. versionadded:: 1.12.0

Added the ``optimize`` argument which will optimize the contraction order
of an einsum expression. For a contraction with three or more operands this
can greatly increase the computational efficiency at the cost of a larger
memory footprint during computation.

Typically a 'greedy' algorithm is applied which empirical tests have shown

returns the optimal path in the majority of cases. In some cases 'optimal'
will return the superlative path through a more expensive, exhaustive
search.
For iterative calculations it may be advisable to calculate the optimal
path
once and reuse that path by supplying it as an argument. An example is
given
below.

See :py:func:`numpy.einsum_path` for more details.

Examples
--------
>>> a = np.arange(25).reshape(5,5)
>>> b = np.arange(5)
>>> c = np.arange(6).reshape(2,3)

Trace of a matrix:

>>> np.einsum('ii', a)
60
>>> np.einsum(a, [0,0])
60
>>> np.trace(a)
60

Extract the diagonal (requires explicit form):

>>> np.einsum('ii->i', a)
array([ 0, 6, 12, 18, 24])
>>> np.einsum(a, [0,0], [0])
array([ 0, 6, 12, 18, 24])
>>> np.diag(a)
array([ 0, 6, 12, 18, 24])

Sum over an axis (requires explicit form):

>>> np.einsum('ij->i', a)
array([ 10, 35, 60, 85, 110])
>>> np.einsum(a, [0,1], [0])
array([ 10, 35, 60, 85, 110])
 >>> np.sum(a, axis=1)
array([ 10, 35, 60, 85, 110])

For higher dimensional arrays summing a single axis can be done with
ellipsis:

>>> np.einsum('...j->...', a)
array([ 10, 35, 60, 85, 110])
>>> np.einsum(a, [Ellipsis,1], [Ellipsis])
array([ 10, 35, 60, 85, 110])

Compute a matrix transpose, or reorder any number of axes:

>>> np.einsum('ji', c)
array([[0, 3],
[1, 4],
[2, 5]])
>>> np.einsum('ij->ji', c)
array([[0, 3],
[1, 4],
[2, 5]])
>>> np.einsum(c, [1,0])
array([[0, 3],
[1, 4],
[2, 5]])
>>> np.transpose(c)
array([[0, 3],
[1, 4],
[2, 5]])

Vector inner products:

>>> np.einsum('i,i', b, b)
30
>>> np.einsum(b, [0], b, [0])
30
>>> np.inner(b,b)
30

Matrix vector multiplication:

>>> np.einsum('ij,j', a, b)
array([ 30, 80, 130, 180, 230])
>>> np.einsum(a, [0,1], b, [1])
array([ 30, 80, 130, 180, 230])
>>> np.dot(a, b)
array([ 30, 80, 130, 180, 230])
>>> np.einsum('...j,j', a, b)
array([ 30, 80, 130, 180, 230])

Broadcasting and scalar multiplication:

>>> np.einsum('..., ...', 3, c)

array([[ 0, 3, 6],
[ 9, 12, 15]])
>>> np.einsum(',ij', 3, c)
array([[ 0, 3, 6],
[ 9, 12, 15]])
>>> np.einsum(3, [Ellipsis], c, [Ellipsis])
array([[ 0, 3, 6],
[ 9, 12, 15]])
>>> np.multiply(3, c)
array([[ 0, 3, 6],
[ 9, 12, 15]])

Vector outer product:

>>> np.einsum('i,j', np.arange(2)+1, b)

array([[0, 1, 2, 3, 4],
[0, 2, 4, 6, 8]])
>>> np.einsum(np.arange(2)+1, [0], b, [1])
array([[0, 1, 2, 3, 4],
[0, 2, 4, 6, 8]])
>>> np.outer(np.arange(2)+1, b)
array([[0, 1, 2, 3, 4],
[0, 2, 4, 6, 8]])

Tensor contraction:

>>> a = np.arange(60.).reshape(3,4,5)
>>> b = np.arange(24.).reshape(4,3,2)
>>> np.einsum('ijk,jil->kl', a, b)
array([[4400., 4730.],
[4532., 4874.],
[4664., 5018.],
[4796., 5162.],
[4928., 5306.]])
>>> np.einsum(a, [0,1,2], b, [1,0,3], [2,3])
array([[4400., 4730.],
[4532., 4874.],
[4664., 5018.],
[4796., 5162.],
[4928., 5306.]])
>>> np.tensordot(a,b, axes=([1,0],[0,1]))
array([[4400., 4730.],
[4532., 4874.],
[4664., 5018.],
[4796., 5162.],
[4928., 5306.]])

Writeable returned arrays (since version 1.10.0):

>>> a = np.zeros((3, 3))

>>> np.einsum('ii->i', a)[:] = 1
>>> a
array([[1., 0., 0.],
[0., 1., 0.],
[0., 0., 1.]])

Example of ellipsis use:

>>> a = np.arange(6).reshape((3,2))
>>> b = np.arange(12).reshape((4,3))
>>> np.einsum('ki,jk->ij', a, b)
array([[10, 28, 46, 64],
[13, 40, 67, 94]])
>>> np.einsum('ki,...k->i...', a, b)
array([[10, 28, 46, 64],
 [13, 40, 67, 94]])
>>> np.einsum('k...,jk', a, b)
array([[10, 28, 46, 64],
[13, 40, 67, 94]])

Chained array operations. For more complicated contractions, speed ups

might be achieved by repeatedly computing a 'greedy' path or pre-computing
the
'optimal' path and repeatedly applying it, using an
`einsum_path` insertion (since version 1.12.0). Performance improvements
can be
particularly significant with larger arrays:

>>> a = np.ones(64).reshape(2,4,8)

Basic `einsum`: ~1520ms (benchmarked on 3.1GHz Intel i5.)

>>> for iteration in range(500):

... _ = np.einsum('ijk,ilm,njm,nlk,abc->',a,a,a,a,a)

Sub-optimal `einsum` (due to repeated path calculation time): ~330ms

>>> for iteration in range(500):

... _ = np.einsum('ijk,ilm,njm,nlk,abc->',a,a,a,a,a,
optimize='optimal')

Greedy `einsum` (faster optimal path approximation): ~160ms

>>> for iteration in range(500):

... _ = np.einsum('ijk,ilm,njm,nlk,abc->',a,a,a,a,a, optimize='greedy')

Optimal `einsum` (best usage pattern in some use cases): ~110ms

>>> path = np.einsum_path('ijk,ilm,njm,nlk,abc->',a,a,a,a,a,

optimize='optimal')[0]
>>> for iteration in range(500):
... _ = np.einsum('ijk,ilm,njm,nlk,abc->',a,a,a,a,a, optimize=path)

einsum_path(*operands, optimize='greedy', einsum_call=False)

einsum_path(subscripts, *operands, optimize='greedy')

Evaluates the lowest cost contraction order for an einsum expression by

considering the creation of intermediate arrays.

Parameters
----------
subscripts : str
Specifies the subscripts for summation.
*operands : list of array_like
These are the arrays for the operation.
optimize : {bool, list, tuple, 'greedy', 'optimal'}
Choose the type of path. If a tuple is provided, the second argument is
assumed to be the maximum intermediate size created. If only a single
argument is provided the largest input or output array size is used
as a maximum intermediate size.

* if a list is given that starts with ``einsum_path``, uses this as the

contraction path
* if False no optimization is taken
 * if True defaults to the 'greedy' algorithm
* 'optimal' An algorithm that combinatorially explores all possible
ways of contracting the listed tensors and chooses the least costly
path. Scales exponentially with the number of terms in the
contraction.
* 'greedy' An algorithm that chooses the best pair contraction
at each step. Effectively, this algorithm searches the largest inner,
Hadamard, and then outer products at each step. Scales cubically with
the number of terms in the contraction. Equivalent to the 'optimal'
path for most contractions.

Default is 'greedy'.

Returns
-------
path : list of tuples
A list representation of the einsum path.
string_repr : str
A printable representation of the einsum path.

Notes
-----
The resulting path indicates which terms of the input contraction should be
contracted first, the result of this contraction is then appended to the
end of the contraction list. This list can then be iterated over until all
intermediate contractions are complete.

See Also
--------
einsum, linalg.multi_dot

Examples
--------

We can begin with a chain dot example. In this case, it is optimal to

contract the ``b`` and ``c`` tensors first as represented by the first
element of the path ``(1, 2)``. The resulting tensor is added to the end
of the contraction and the remaining contraction ``(0, 1)`` is then
completed.

>>> np.random.seed(123)
>>> a = np.random.rand(2, 2)
>>> b = np.random.rand(2, 5)
>>> c = np.random.rand(5, 2)
>>> path_info = np.einsum_path('ij,jk,kl->il', a, b, c, optimize='greedy')
>>> print(path_info[0])
['einsum_path', (1, 2), (0, 1)]
>>> print(path_info[1])
Complete contraction: ij,jk,kl->il # may vary
Naive scaling: 4
Optimized scaling: 3
Naive FLOP count: 1.600e+02
Optimized FLOP count: 5.600e+01
Theoretical speedup: 2.857
Largest intermediate: 4.000e+00 elements
-------------------------------------------------------------------------
scaling current remaining
-------------------------------------------------------------------------
3 kl,jk->jl ij,jl->il
 3 jl,ij->il il->il

A more complex index transformation example.

>>> I = np.random.rand(10, 10, 10, 10)

>>> C = np.random.rand(10, 10)
>>> path_info = np.einsum_path('ea,fb,abcd,gc,hd->efgh', C, C, I, C, C,
... optimize='greedy')

>>> print(path_info[0])
['einsum_path', (0, 2), (0, 3), (0, 2), (0, 1)]
>>> print(path_info[1])
Complete contraction: ea,fb,abcd,gc,hd->efgh # may vary
Naive scaling: 8
Optimized scaling: 5
Naive FLOP count: 8.000e+08
Optimized FLOP count: 8.000e+05
Theoretical speedup: 1000.000
Largest intermediate: 1.000e+04 elements
--------------------------------------------------------------------------
scaling current remaining
--------------------------------------------------------------------------
5 abcd,ea->bcde fb,gc,hd,bcde->efgh
5 bcde,fb->cdef gc,hd,cdef->efgh
5 cdef,gc->defg hd,defg->efgh
5 defg,hd->efgh efgh->efgh

empty(...)
empty(shape, dtype=float, order='C', *, like=None)

Return a new array of given shape and type, without initializing entries.

Parameters
----------
shape : int or tuple of int
Shape of the empty array, e.g., ``(2, 3)`` or ``2``.
dtype : data-type, optional
Desired output data-type for the array, e.g, `numpy.int8`. Default is
`numpy.float64`.
order : {'C', 'F'}, optional, default: 'C'
Whether to store multi-dimensional data in row-major
(C-style) or column-major (Fortran-style) order in
memory.
like : array_like, optional
Reference object to allow the creation of arrays which are not
NumPy arrays. If an array-like passed in as ``like`` supports
the ``__array_function__`` protocol, the result will be defined
by it. In this case, it ensures the creation of an array object
compatible with that passed in via this argument.

.. versionadded:: 1.20.0

Returns
-------
out : ndarray
Array of uninitialized (arbitrary) data of the given shape, dtype, and
order. Object arrays will be initialized to None.
 See Also
--------
empty_like : Return an empty array with shape and type of input.
ones : Return a new array setting values to one.
zeros : Return a new array setting values to zero.
full : Return a new array of given shape filled with value.

Notes
-----
`empty`, unlike `zeros`, does not set the array values to zero,
and may therefore be marginally faster. On the other hand, it requires
the user to manually set all the values in the array, and should be
used with caution.

Examples
--------
>>> np.empty([2, 2])
array([[ -9.74499359e+001, 6.69583040e-309],
[ 2.13182611e-314, 3.06959433e-309]]) #uninitialized

>>> np.empty([2, 2], dtype=int)

array([[-1073741821, -1067949133],
[ 496041986, 19249760]]) #uninitialized

empty_like(...)
empty_like(prototype, dtype=None, order='K', subok=True, shape=None)

Return a new array with the same shape and type as a given array.

Parameters
----------
prototype : array_like
The shape and data-type of `prototype` define these same attributes
of the returned array.
dtype : data-type, optional
Overrides the data type of the result.

.. versionadded:: 1.6.0
order : {'C', 'F', 'A', or 'K'}, optional
Overrides the memory layout of the result. 'C' means C-order,
'F' means F-order, 'A' means 'F' if `prototype` is Fortran
contiguous, 'C' otherwise. 'K' means match the layout of `prototype`
as closely as possible.

.. versionadded:: 1.6.0
subok : bool, optional.
If True, then the newly created array will use the sub-class
type of `prototype`, otherwise it will be a base-class array. Defaults
to True.
shape : int or sequence of ints, optional.
Overrides the shape of the result. If order='K' and the number of
dimensions is unchanged, will try to keep order, otherwise,
order='C' is implied.

.. versionadded:: 1.17.0

Returns
-------
 out : ndarray
Array of uninitialized (arbitrary) data with the same
shape and type as `prototype`.

See Also
--------
ones_like : Return an array of ones with shape and type of input.
zeros_like : Return an array of zeros with shape and type of input.
full_like : Return a new array with shape of input filled with value.
empty : Return a new uninitialized array.

Notes
-----
This function does *not* initialize the returned array; to do that use
`zeros_like` or `ones_like` instead. It may be marginally faster than
the functions that do set the array values.

Examples
--------
>>> a = ([1,2,3], [4,5,6]) # a is array-like
>>> np.empty_like(a)
array([[-1073741821, -1073741821, 3], # uninitialized
[ 0, 0, -1073741821]])
>>> a = np.array([[1., 2., 3.],[4.,5.,6.]])
>>> np.empty_like(a)
array([[ -2.00000715e+000, 1.48219694e-323, -2.00000572e+000], #
uninitialized
[ 4.38791518e-305, -2.00000715e+000, 4.17269252e-309]])

expand_dims(a, axis)
Expand the shape of an array.

Insert a new axis that will appear at the `axis` position in the expanded
array shape.

Parameters
----------
a : array_like
Input array.
axis : int or tuple of ints
Position in the expanded axes where the new axis (or axes) is placed.

.. deprecated:: 1.13.0
Passing an axis where ``axis > a.ndim`` will be treated as
``axis == a.ndim``, and passing ``axis < -a.ndim - 1`` will
be treated as ``axis == 0``. This behavior is deprecated.

.. versionchanged:: 1.18.0
A tuple of axes is now supported. Out of range axes as
described above are now forbidden and raise an `AxisError`.

Returns
-------
result : ndarray
View of `a` with the number of dimensions increased.

See Also
--------
squeeze : The inverse operation, removing singleton dimensions
 reshape : Insert, remove, and combine dimensions, and resize existing ones
doc.indexing, atleast_1d, atleast_2d, atleast_3d

Examples
--------
>>> x = np.array([1, 2])
>>> x.shape
(2,)

The following is equivalent to ``x[np.newaxis, :]`` or ``x[np.newaxis]``:

>>> y = np.expand_dims(x, axis=0)

>>> y
array([[1, 2]])
>>> y.shape
(1, 2)

The following is equivalent to ``x[:, np.newaxis]``:

>>> y = np.expand_dims(x, axis=1)

>>> y
array([[1],
[2]])
>>> y.shape
(2, 1)

``axis`` may also be a tuple:

>>> y = np.expand_dims(x, axis=(0, 1))

>>> y
array([[[1, 2]]])

>>> y = np.expand_dims(x, axis=(2, 0))

>>> y
array([[[1],
[2]]])

Note that some examples may use ``None`` instead of ``np.newaxis``. These
are the same objects:

>>> np.newaxis is None

True

extract(condition, arr)
Return the elements of an array that satisfy some condition.

This is equivalent to ``np.compress(ravel(condition), ravel(arr))``. If

`condition` is boolean ``np.extract`` is equivalent to ``arr[condition]``.

Note that `place` does the exact opposite of `extract`.

Parameters
----------
condition : array_like
An array whose nonzero or True entries indicate the elements of `arr`
to extract.
arr : array_like
Input array of the same size as `condition`.
 Returns
-------
extract : ndarray
Rank 1 array of values from `arr` where `condition` is True.

See Also
--------
take, put, copyto, compress, place

Examples
--------
>>> arr = np.arange(12).reshape((3, 4))
>>> arr
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])
>>> condition = np.mod(arr, 3)==0
>>> condition
array([[ True, False, False, True],
[False, False, True, False],
[False, True, False, False]])
>>> np.extract(condition, arr)
array([0, 3, 6, 9])

If `condition` is boolean:

>>> arr[condition]
array([0, 3, 6, 9])

eye(N, M=None, k=0, dtype=<class 'float'>, order='C', *, like=None)

Return a 2-D array with ones on the diagonal and zeros elsewhere.

Parameters
----------
N : int
Number of rows in the output.
M : int, optional
Number of columns in the output. If None, defaults to `N`.
k : int, optional
Index of the diagonal: 0 (the default) refers to the main diagonal,
a positive value refers to an upper diagonal, and a negative value
to a lower diagonal.
dtype : data-type, optional
Data-type of the returned array.
order : {'C', 'F'}, optional
Whether the output should be stored in row-major (C-style) or
column-major (Fortran-style) order in memory.

.. versionadded:: 1.14.0
like : array_like, optional
Reference object to allow the creation of arrays which are not
NumPy arrays. If an array-like passed in as ``like`` supports
the ``__array_function__`` protocol, the result will be defined
by it. In this case, it ensures the creation of an array object
compatible with that passed in via this argument.

.. versionadded:: 1.20.0
 Returns
-------
I : ndarray of shape (N,M)
An array where all elements are equal to zero, except for the `k`-th
diagonal, whose values are equal to one.

See Also
--------
identity : (almost) equivalent function
diag : diagonal 2-D array from a 1-D array specified by the user.

Examples
--------
>>> np.eye(2, dtype=int)
array([[1, 0],
[0, 1]])
>>> np.eye(3, k=1)
array([[0., 1., 0.],
[0., 0., 1.],
[0., 0., 0.]])

fastCopyAndTranspose(...)
fastCopyAndTranspose(a)

.. deprecated:: 1.24

fastCopyAndTranspose is deprecated and will be removed. Use the copy and

transpose methods instead, e.g. ``arr.T.copy()``

fill_diagonal(a, val, wrap=False)

Fill the main diagonal of the given array of any dimensionality.

For an array `a` with ``a.ndim >= 2``, the diagonal is the list of
locations with indices ``a[i, ..., i]`` all identical. This function
modifies the input array in-place, it does not return a value.

Parameters
----------
a : array, at least 2-D.
Array whose diagonal is to be filled, it gets modified in-place.

val : scalar or array_like

Value(s) to write on the diagonal. If `val` is scalar, the value is
written along the diagonal. If array-like, the flattened `val` is
written along the diagonal, repeating if necessary to fill all
diagonal entries.

wrap : bool
For tall matrices in NumPy version up to 1.6.2, the
diagonal "wrapped" after N columns. You can have this behavior
with this option. This affects only tall matrices.

See also
--------
diag_indices, diag_indices_from

Notes
-----
.. versionadded:: 1.4.0
This functionality can be obtained via `diag_indices`, but internally
this version uses a much faster implementation that never constructs the
indices and uses simple slicing.

Examples
--------
>>> a = np.zeros((3, 3), int)
>>> np.fill_diagonal(a, 5)
>>> a
array([[5, 0, 0],
[0, 5, 0],
[0, 0, 5]])

The same function can operate on a 4-D array:

>>> a = np.zeros((3, 3, 3, 3), int)

>>> np.fill_diagonal(a, 4)

We only show a few blocks for clarity:

>>> a[0, 0]
array([[4, 0, 0],
[0, 0, 0],
[0, 0, 0]])
>>> a[1, 1]
array([[0, 0, 0],
[0, 4, 0],
[0, 0, 0]])
>>> a[2, 2]
array([[0, 0, 0],
[0, 0, 0],
[0, 0, 4]])

The wrap option affects only tall matrices:

>>> # tall matrices no wrap

>>> a = np.zeros((5, 3), int)
>>> np.fill_diagonal(a, 4)
>>> a
array([[4, 0, 0],
[0, 4, 0],
[0, 0, 4],
[0, 0, 0],
[0, 0, 0]])

>>> # tall matrices wrap

>>> a = np.zeros((5, 3), int)
>>> np.fill_diagonal(a, 4, wrap=True)
>>> a
array([[4, 0, 0],
[0, 4, 0],
[0, 0, 4],
[0, 0, 0],
[4, 0, 0]])

>>> # wide matrices

>>> a = np.zeros((3, 5), int)
>>> np.fill_diagonal(a, 4, wrap=True)
 >>> a
array([[4, 0, 0, 0, 0],
[0, 4, 0, 0, 0],
[0, 0, 4, 0, 0]])

The anti-diagonal can be filled by reversing the order of elements

using either `numpy.flipud` or `numpy.fliplr`.

>>> a = np.zeros((3, 3), int);

>>> np.fill_diagonal(np.fliplr(a), [1,2,3]) # Horizontal flip
>>> a
array([[0, 0, 1],
[0, 2, 0],
[3, 0, 0]])
>>> np.fill_diagonal(np.flipud(a), [1,2,3]) # Vertical flip
>>> a
array([[0, 0, 3],
[0, 2, 0],
[1, 0, 0]])

Note that the order in which the diagonal is filled varies depending
on the flip function.

find_common_type(array_types, scalar_types)
Determine common type following standard coercion rules.

.. deprecated:: NumPy 1.25

This function is deprecated, use `numpy.promote_types` or

`numpy.result_type` instead. To achieve semantics for the
`scalar_types` argument, use `numpy.result_type` and pass the Python
values `0`, `0.0`, or `0j`.
This will give the same results in almost all cases.
More information and rare exception can be found in the
`NumPy 1.25 release notes <https://numpy.org/devdocs/release/1.25.0-
notes.html>`_.

Parameters
----------
array_types : sequence
A list of dtypes or dtype convertible objects representing arrays.
scalar_types : sequence
A list of dtypes or dtype convertible objects representing scalars.

Returns
-------
datatype : dtype
The common data type, which is the maximum of `array_types` ignoring
`scalar_types`, unless the maximum of `scalar_types` is of a
different kind (`dtype.kind`). If the kind is not understood, then
None is returned.

See Also
--------
dtype, common_type, can_cast, mintypecode

Examples
--------
>>> np.find_common_type([], [np.int64, np.float32, complex])
 dtype('complex128')
>>> np.find_common_type([np.int64, np.float32], [])
dtype('float64')

The standard casting rules ensure that a scalar cannot up-cast an

array unless the scalar is of a fundamentally different kind of data
(i.e. under a different hierarchy in the data type hierarchy) then
the array:

>>> np.find_common_type([np.float32], [np.int64, np.float64])

dtype('float32')

Complex is of a different type, so it up-casts the float in the

`array_types` argument:

>>> np.find_common_type([np.float32], [complex])

dtype('complex128')

Type specifier strings are convertible to dtypes and can therefore

be used instead of dtypes:

>>> np.find_common_type(['f4', 'f4', 'i4'], ['c8'])

dtype('complex128')

fix(x, out=None)
Round to nearest integer towards zero.

Round an array of floats element-wise to nearest integer towards zero.

The rounded values are returned as floats.

Parameters
----------
x : array_like
An array of floats to be rounded
out : ndarray, optional
A location into which the result is stored. If provided, it must have
a shape that the input broadcasts to. If not provided or None, a
freshly-allocated array is returned.

Returns
-------
out : ndarray of floats
A float array with the same dimensions as the input.
If second argument is not supplied then a float array is returned
with the rounded values.

If a second argument is supplied the result is stored there.

The return value `out` is then a reference to that array.

See Also
--------
rint, trunc, floor, ceil
around : Round to given number of decimals

Examples
--------
>>> np.fix(3.14)
3.0
>>> np.fix(3)
 3.0
>>> np.fix([2.1, 2.9, -2.1, -2.9])
array([ 2., 2., -2., -2.])

flatnonzero(a)
Return indices that are non-zero in the flattened version of a.

This is equivalent to ``np.nonzero(np.ravel(a))[0]``.

Parameters
----------
a : array_like
Input data.

Returns
-------
res : ndarray
Output array, containing the indices of the elements of ``a.ravel()``
that are non-zero.

See Also
--------
nonzero : Return the indices of the non-zero elements of the input array.
ravel : Return a 1-D array containing the elements of the input array.

Examples
--------
>>> x = np.arange(-2, 3)
>>> x
array([-2, -1, 0, 1, 2])
>>> np.flatnonzero(x)
array([0, 1, 3, 4])

Use the indices of the non-zero elements as an index array to extract

these elements:

>>> x.ravel()[np.flatnonzero(x)]
array([-2, -1, 1, 2])

flip(m, axis=None)
Reverse the order of elements in an array along the given axis.

The shape of the array is preserved, but the elements are reordered.

.. versionadded:: 1.12.0

Parameters
----------
m : array_like
Input array.
axis : None or int or tuple of ints, optional
Axis or axes along which to flip over. The default,
axis=None, will flip over all of the axes of the input array.
If axis is negative it counts from the last to the first axis.

If axis is a tuple of ints, flipping is performed on all of the axes

specified in the tuple.

.. versionchanged:: 1.15.0
 None and tuples of axes are supported

Returns
-------
out : array_like
A view of `m` with the entries of axis reversed. Since a view is
returned, this operation is done in constant time.

See Also
--------
flipud : Flip an array vertically (axis=0).
fliplr : Flip an array horizontally (axis=1).

Notes
-----
flip(m, 0) is equivalent to flipud(m).

flip(m, 1) is equivalent to fliplr(m).

flip(m, n) corresponds to ``m[...,::-1,...]`` with ``::-1`` at position n.

flip(m) corresponds to ``m[::-1,::-1,...,::-1]`` with ``::-1`` at all

positions.

flip(m, (0, 1)) corresponds to ``m[::-1,::-1,...]`` with ``::-1`` at

position 0 and position 1.

Examples
--------
>>> A = np.arange(8).reshape((2,2,2))
>>> A
array([[[0, 1],
[2, 3]],
[[4, 5],
[6, 7]]])
>>> np.flip(A, 0)
array([[[4, 5],
[6, 7]],
[[0, 1],
[2, 3]]])
>>> np.flip(A, 1)
array([[[2, 3],
[0, 1]],
[[6, 7],
[4, 5]]])
>>> np.flip(A)
array([[[7, 6],
[5, 4]],
[[3, 2],
[1, 0]]])
>>> np.flip(A, (0, 2))
array([[[5, 4],
[7, 6]],
[[1, 0],
[3, 2]]])
>>> A = np.random.randn(3,4,5)
>>> np.all(np.flip(A,2) == A[:,:,::-1,...])
True
fliplr(m)
Reverse the order of elements along axis 1 (left/right).

For a 2-D array, this flips the entries in each row in the left/right
direction. Columns are preserved, but appear in a different order than
before.

Parameters
----------
m : array_like
Input array, must be at least 2-D.

Returns
-------
f : ndarray
A view of `m` with the columns reversed. Since a view
is returned, this operation is :math:`\mathcal O(1)`.

See Also
--------
flipud : Flip array in the up/down direction.
flip : Flip array in one or more dimensions.
rot90 : Rotate array counterclockwise.

Notes
-----
Equivalent to ``m[:,::-1]`` or ``np.flip(m, axis=1)``.
Requires the array to be at least 2-D.

Examples
--------
>>> A = np.diag([1.,2.,3.])
>>> A
array([[1., 0., 0.],
[0., 2., 0.],
[0., 0., 3.]])
>>> np.fliplr(A)
array([[0., 0., 1.],
[0., 2., 0.],
[3., 0., 0.]])

>>> A = np.random.randn(2,3,5)
>>> np.all(np.fliplr(A) == A[:,::-1,...])
True

flipud(m)
Reverse the order of elements along axis 0 (up/down).

For a 2-D array, this flips the entries in each column in the up/down
direction. Rows are preserved, but appear in a different order than before.

Parameters
----------
m : array_like
Input array.

Returns
-------
out : array_like
 A view of `m` with the rows reversed. Since a view is
returned, this operation is :math:`\mathcal O(1)`.

See Also
--------
fliplr : Flip array in the left/right direction.
flip : Flip array in one or more dimensions.
rot90 : Rotate array counterclockwise.

Notes
-----
Equivalent to ``m[::-1, ...]`` or ``np.flip(m, axis=0)``.
Requires the array to be at least 1-D.

Examples
--------
>>> A = np.diag([1.0, 2, 3])
>>> A
array([[1., 0., 0.],
[0., 2., 0.],
[0., 0., 3.]])
>>> np.flipud(A)
array([[0., 0., 3.],
[0., 2., 0.],
[1., 0., 0.]])

>>> A = np.random.randn(2,3,5)
>>> np.all(np.flipud(A) == A[::-1,...])
True

>>> np.flipud([1,2])
array([2, 1])

format_float_positional(x, precision=None, unique=True, fractional=True,

trim='k', sign=False, pad_left=None, pad_right=None, min_digits=None)
Format a floating-point scalar as a decimal string in positional notation.

Provides control over rounding, trimming and padding. Uses and assumes
IEEE unbiased rounding. Uses the "Dragon4" algorithm.

Parameters
----------
x : python float or numpy floating scalar
Value to format.
precision : non-negative integer or None, optional
Maximum number of digits to print. May be None if `unique` is
`True`, but must be an integer if unique is `False`.
unique : boolean, optional
If `True`, use a digit-generation strategy which gives the shortest
representation which uniquely identifies the floating-point number from
other values of the same type, by judicious rounding. If `precision`
is given fewer digits than necessary can be printed, or if `min_digits`
is given more can be printed, in which cases the last digit is rounded
with unbiased rounding.
If `False`, digits are generated as if printing an infinite-precision
value and stopping after `precision` digits, rounding the remaining
value with unbiased rounding
fractional : boolean, optional
If `True`, the cutoffs of `precision` and `min_digits` refer to the
 total number of digits after the decimal point, including leading
zeros.
If `False`, `precision` and `min_digits` refer to the total number of
significant digits, before or after the decimal point, ignoring leading
zeros.
trim : one of 'k', '.', '0', '-', optional
Controls post-processing trimming of trailing digits, as follows:

* 'k' : keep trailing zeros, keep decimal point (no trimming)

* '.' : trim all trailing zeros, leave decimal point
* '0' : trim all but the zero before the decimal point. Insert the
zero if it is missing.
* '-' : trim trailing zeros and any trailing decimal point
sign : boolean, optional
Whether to show the sign for positive values.
pad_left : non-negative integer, optional
Pad the left side of the string with whitespace until at least that
many characters are to the left of the decimal point.
pad_right : non-negative integer, optional
Pad the right side of the string with whitespace until at least that
many characters are to the right of the decimal point.
min_digits : non-negative integer or None, optional
Minimum number of digits to print. Only has an effect if `unique=True`
in which case additional digits past those necessary to uniquely
identify the value may be printed, rounding the last additional digit.

-- versionadded:: 1.21.0

Returns
-------
rep : string
The string representation of the floating point value

See Also
--------
format_float_scientific

Examples
--------
>>> np.format_float_positional(np.float32(np.pi))
'3.1415927'
>>> np.format_float_positional(np.float16(np.pi))
'3.14'
>>> np.format_float_positional(np.float16(0.3))
'0.3'
>>> np.format_float_positional(np.float16(0.3), unique=False, precision=10)
'0.3000488281'

format_float_scientific(x, precision=None, unique=True, trim='k', sign=False,

pad_left=None, exp_digits=None, min_digits=None)
Format a floating-point scalar as a decimal string in scientific notation.

Provides control over rounding, trimming and padding. Uses and assumes
IEEE unbiased rounding. Uses the "Dragon4" algorithm.

Parameters
----------
x : python float or numpy floating scalar
Value to format.
 precision : non-negative integer or None, optional
Maximum number of digits to print. May be None if `unique` is
`True`, but must be an integer if unique is `False`.
unique : boolean, optional
If `True`, use a digit-generation strategy which gives the shortest
representation which uniquely identifies the floating-point number from
other values of the same type, by judicious rounding. If `precision`
is given fewer digits than necessary can be printed. If `min_digits`
is given more can be printed, in which cases the last digit is rounded
with unbiased rounding.
If `False`, digits are generated as if printing an infinite-precision
value and stopping after `precision` digits, rounding the remaining
value with unbiased rounding
trim : one of 'k', '.', '0', '-', optional
Controls post-processing trimming of trailing digits, as follows:

* 'k' : keep trailing zeros, keep decimal point (no trimming)

* '.' : trim all trailing zeros, leave decimal point
* '0' : trim all but the zero before the decimal point. Insert the
zero if it is missing.
* '-' : trim trailing zeros and any trailing decimal point
sign : boolean, optional
Whether to show the sign for positive values.
pad_left : non-negative integer, optional
Pad the left side of the string with whitespace until at least that
many characters are to the left of the decimal point.
exp_digits : non-negative integer, optional
Pad the exponent with zeros until it contains at least this many
digits.
If omitted, the exponent will be at least 2 digits.
min_digits : non-negative integer or None, optional
Minimum number of digits to print. This only has an effect for
`unique=True`. In that case more digits than necessary to uniquely
identify the value may be printed and rounded unbiased.

-- versionadded:: 1.21.0

Returns
-------
rep : string
The string representation of the floating point value

See Also
--------
format_float_positional

Examples
--------
>>> np.format_float_scientific(np.float32(np.pi))
'3.1415927e+00'
>>> s = np.float32(1.23e24)
>>> np.format_float_scientific(s, unique=False, precision=15)
'1.230000071797338e+24'
>>> np.format_float_scientific(s, exp_digits=4)
'1.23e+0024'

from_dlpack(...)
from_dlpack(x, /)
 Create a NumPy array from an object implementing the ``__dlpack__``
protocol. Generally, the returned NumPy array is a read-only view
of the input object. See [1]_ and [2]_ for more details.

Parameters
----------
x : object
A Python object that implements the ``__dlpack__`` and
``__dlpack_device__`` methods.

Returns
-------
out : ndarray

References
----------
.. [1] Array API documentation,

https://data-apis.org/array-api/latest/design_topics/data_interchange.html#syntax-
for-data-interchange-with-dlpack

.. [2] Python specification for DLPack,

https://dmlc.github.io/dlpack/latest/python_spec.html

Examples
--------
>>> import torch
>>> x = torch.arange(10)
>>> # create a view of the torch tensor "x" in NumPy
>>> y = np.from_dlpack(x)

frombuffer(...)
frombuffer(buffer, dtype=float, count=-1, offset=0, *, like=None)

Interpret a buffer as a 1-dimensional array.

Parameters
----------
buffer : buffer_like
An object that exposes the buffer interface.
dtype : data-type, optional
Data-type of the returned array; default: float.
count : int, optional
Number of items to read. ``-1`` means all data in the buffer.
offset : int, optional
Start reading the buffer from this offset (in bytes); default: 0.
like : array_like, optional
Reference object to allow the creation of arrays which are not
NumPy arrays. If an array-like passed in as ``like`` supports
the ``__array_function__`` protocol, the result will be defined
by it. In this case, it ensures the creation of an array object
compatible with that passed in via this argument.

.. versionadded:: 1.20.0

Returns
-------
out : ndarray
 See also
--------
ndarray.tobytes
Inverse of this operation, construct Python bytes from the raw data
bytes in the array.

Notes
-----
If the buffer has data that is not in machine byte-order, this should
be specified as part of the data-type, e.g.::

>>> dt = np.dtype(int)
>>> dt = dt.newbyteorder('>')
>>> np.frombuffer(buf, dtype=dt) # doctest: +SKIP

The data of the resulting array will not be byteswapped, but will be
interpreted correctly.

This function creates a view into the original object. This should be safe
in general, but it may make sense to copy the result when the original
object is mutable or untrusted.

Examples
--------
>>> s = b'hello world'
>>> np.frombuffer(s, dtype='S1', count=5, offset=6)
array([b'w', b'o', b'r', b'l', b'd'], dtype='|S1')

>>> np.frombuffer(b'\x01\x02', dtype=np.uint8)

array([1, 2], dtype=uint8)
>>> np.frombuffer(b'\x01\x02\x03\x04\x05', dtype=np.uint8, count=3)
array([1, 2, 3], dtype=uint8)

fromfile(...)
fromfile(file, dtype=float, count=-1, sep='', offset=0, *, like=None)

Construct an array from data in a text or binary file.

A highly efficient way of reading binary data with a known data-type,

as well as parsing simply formatted text files. Data written using the
`tofile` method can be read using this function.

Parameters
----------
file : file or str or Path
Open file object or filename.

.. versionchanged:: 1.17.0
`pathlib.Path` objects are now accepted.

dtype : data-type
Data type of the returned array.
For binary files, it is used to determine the size and byte-order
of the items in the file.
Most builtin numeric types are supported and extension types may be
supported.

.. versionadded:: 1.18.0
Complex dtypes.
count : int
Number of items to read. ``-1`` means all items (i.e., the complete
file).
sep : str
Separator between items if file is a text file.
Empty ("") separator means the file should be treated as binary.
Spaces (" ") in the separator match zero or more whitespace characters.
A separator consisting only of spaces must match at least one
whitespace.
offset : int
The offset (in bytes) from the file's current position. Defaults to 0.
Only permitted for binary files.

.. versionadded:: 1.17.0
like : array_like, optional
Reference object to allow the creation of arrays which are not
NumPy arrays. If an array-like passed in as ``like`` supports
the ``__array_function__`` protocol, the result will be defined
by it. In this case, it ensures the creation of an array object
compatible with that passed in via this argument.

.. versionadded:: 1.20.0

See also
--------
load, save
ndarray.tofile
loadtxt : More flexible way of loading data from a text file.

Notes
-----
Do not rely on the combination of `tofile` and `fromfile` for
data storage, as the binary files generated are not platform
independent. In particular, no byte-order or data-type information is
saved. Data can be stored in the platform independent ``.npy`` format
using `save` and `load` instead.

Examples
--------
Construct an ndarray:

>>> dt = np.dtype([('time', [('min', np.int64), ('sec', np.int64)]),

... ('temp', float)])
>>> x = np.zeros((1,), dtype=dt)
>>> x['time']['min'] = 10; x['temp'] = 98.25
>>> x
array([((10, 0), 98.25)],
dtype=[('time', [('min', '<i8'), ('sec', '<i8')]), ('temp', '<f8')])

Save the raw data to disk:

>>> import tempfile

>>> fname = tempfile.mkstemp()[1]
>>> x.tofile(fname)

Read the raw data from disk:

>>> np.fromfile(fname, dtype=dt)

 array([((10, 0), 98.25)],
dtype=[('time', [('min', '<i8'), ('sec', '<i8')]), ('temp', '<f8')])

The recommended way to store and load data:

>>> np.save(fname, x)
>>> np.load(fname + '.npy')
array([((10, 0), 98.25)],
dtype=[('time', [('min', '<i8'), ('sec', '<i8')]), ('temp', '<f8')])

fromfunction(function, shape, *, dtype=<class 'float'>, like=None, **kwargs)

Construct an array by executing a function over each coordinate.

The resulting array therefore has a value ``fn(x, y, z)`` at

coordinate ``(x, y, z)``.

Parameters
----------
function : callable
The function is called with N parameters, where N is the rank of
`shape`. Each parameter represents the coordinates of the array
varying along a specific axis. For example, if `shape`
were ``(2, 2)``, then the parameters would be
``array([[0, 0], [1, 1]])`` and ``array([[0, 1], [0, 1]])``
shape : (N,) tuple of ints
Shape of the output array, which also determines the shape of
the coordinate arrays passed to `function`.
dtype : data-type, optional
Data-type of the coordinate arrays passed to `function`.
By default, `dtype` is float.
like : array_like, optional
Reference object to allow the creation of arrays which are not
NumPy arrays. If an array-like passed in as ``like`` supports
the ``__array_function__`` protocol, the result will be defined
by it. In this case, it ensures the creation of an array object
compatible with that passed in via this argument.

.. versionadded:: 1.20.0

Returns
-------
fromfunction : any
The result of the call to `function` is passed back directly.
Therefore the shape of `fromfunction` is completely determined by
`function`. If `function` returns a scalar value, the shape of
`fromfunction` would not match the `shape` parameter.

See Also
--------
indices, meshgrid

Notes
-----
Keywords other than `dtype` and `like` are passed to `function`.

Examples
--------
>>> np.fromfunction(lambda i, j: i, (2, 2), dtype=float)
array([[0., 0.],
 [1., 1.]])

>>> np.fromfunction(lambda i, j: j, (2, 2), dtype=float)

array([[0., 1.],
[0., 1.]])

>>> np.fromfunction(lambda i, j: i == j, (3, 3), dtype=int)

array([[ True, False, False],
[False, True, False],
[False, False, True]])

>>> np.fromfunction(lambda i, j: i + j, (3, 3), dtype=int)

array([[0, 1, 2],
[1, 2, 3],
[2, 3, 4]])

fromiter(...)
fromiter(iter, dtype, count=-1, *, like=None)

Create a new 1-dimensional array from an iterable object.

Parameters
----------
iter : iterable object
An iterable object providing data for the array.
dtype : data-type
The data-type of the returned array.

.. versionchanged:: 1.23
Object and subarray dtypes are now supported (note that the final
result is not 1-D for a subarray dtype).

count : int, optional

The number of items to read from *iterable*. The default is -1,
which means all data is read.
like : array_like, optional
Reference object to allow the creation of arrays which are not
NumPy arrays. If an array-like passed in as ``like`` supports
the ``__array_function__`` protocol, the result will be defined
by it. In this case, it ensures the creation of an array object
compatible with that passed in via this argument.

.. versionadded:: 1.20.0

Returns
-------
out : ndarray
The output array.

Notes
-----
Specify `count` to improve performance. It allows ``fromiter`` to
pre-allocate the output array, instead of resizing it on demand.

Examples
--------
>>> iterable = (x*x for x in range(5))
>>> np.fromiter(iterable, float)
array([ 0., 1., 4., 9., 16.])
 A carefully constructed subarray dtype will lead to higher dimensional
results:

>>> iterable = ((x+1, x+2) for x in range(5))

>>> np.fromiter(iterable, dtype=np.dtype((int, 2)))
array([[1, 2],
[2, 3],
[3, 4],
[4, 5],
[5, 6]])

frompyfunc(...)
frompyfunc(func, /, nin, nout, *[, identity])

Takes an arbitrary Python function and returns a NumPy ufunc.

Can be used, for example, to add broadcasting to a built-in Python

function (see Examples section).

Parameters
----------
func : Python function object
An arbitrary Python function.
nin : int
The number of input arguments.
nout : int
The number of objects returned by `func`.
identity : object, optional
The value to use for the `~numpy.ufunc.identity` attribute of the
resulting
object. If specified, this is equivalent to setting the underlying
C ``identity`` field to ``PyUFunc_IdentityValue``.
If omitted, the identity is set to ``PyUFunc_None``. Note that this is
_not_ equivalent to setting the identity to ``None``, which implies the
operation is reorderable.

Returns
-------
out : ufunc
Returns a NumPy universal function (``ufunc``) object.

See Also
--------
vectorize : Evaluates pyfunc over input arrays using broadcasting rules of
numpy.

Notes
-----
The returned ufunc always returns PyObject arrays.

Examples
--------
Use frompyfunc to add broadcasting to the Python function ``oct``:

>>> oct_array = np.frompyfunc(oct, 1, 1)

>>> oct_array(np.array((10, 30, 100)))
array(['0o12', '0o36', '0o144'], dtype=object)
>>> np.array((oct(10), oct(30), oct(100))) # for comparison
 array(['0o12', '0o36', '0o144'], dtype='<U5')

fromregex(file, regexp, dtype, encoding=None)

Construct an array from a text file, using regular expression parsing.

The returned array is always a structured array, and is constructed from

all matches of the regular expression in the file. Groups in the regular
expression are converted to fields of the structured array.

Parameters
----------
file : path or file
Filename or file object to read.

.. versionchanged:: 1.22.0
Now accepts `os.PathLike` implementations.
regexp : str or regexp
Regular expression used to parse the file.
Groups in the regular expression correspond to fields in the dtype.
dtype : dtype or list of dtypes
Dtype for the structured array; must be a structured datatype.
encoding : str, optional
Encoding used to decode the inputfile. Does not apply to input streams.

.. versionadded:: 1.14.0

Returns
-------
output : ndarray
The output array, containing the part of the content of `file` that
was matched by `regexp`. `output` is always a structured array.

Raises
------
TypeError
When `dtype` is not a valid dtype for a structured array.

See Also
--------
fromstring, loadtxt

Notes
-----
Dtypes for structured arrays can be specified in several forms, but all
forms specify at least the data type and field name. For details see
`basics.rec`.

Examples
--------
>>> from io import StringIO
>>> text = StringIO("1312 foo\n1534 bar\n444 qux")

>>> regexp = r"(\d+)\s+(...)" # match [digits, whitespace, anything]

>>> output = np.fromregex(text, regexp,
... [('num', np.int64), ('key', 'S3')])
>>> output
array([(1312, b'foo'), (1534, b'bar'), ( 444, b'qux')],
dtype=[('num', '<i8'), ('key', 'S3')])
>>> output['num']
 array([1312, 1534, 444])

fromstring(...)
fromstring(string, dtype=float, count=-1, *, sep, like=None)

A new 1-D array initialized from text data in a string.

Parameters
----------
string : str
A string containing the data.
dtype : data-type, optional
The data type of the array; default: float. For binary input data,
the data must be in exactly this format. Most builtin numeric types are
supported and extension types may be supported.

.. versionadded:: 1.18.0
Complex dtypes.

count : int, optional

Read this number of `dtype` elements from the data. If this is
negative (the default), the count will be determined from the
length of the data.
sep : str, optional
The string separating numbers in the data; extra whitespace between
elements is also ignored.

.. deprecated:: 1.14
Passing ``sep=''``, the default, is deprecated since it will
trigger the deprecated binary mode of this function. This mode
interprets `string` as binary bytes, rather than ASCII text with
decimal numbers, an operation which is better spelt
``frombuffer(string, dtype, count)``. If `string` contains unicode
text, the binary mode of `fromstring` will first encode it into
bytes using utf-8, which will not produce sane results.

like : array_like, optional

Reference object to allow the creation of arrays which are not
NumPy arrays. If an array-like passed in as ``like`` supports
the ``__array_function__`` protocol, the result will be defined
by it. In this case, it ensures the creation of an array object
compatible with that passed in via this argument.

.. versionadded:: 1.20.0

Returns
-------
arr : ndarray
The constructed array.

Raises
------
ValueError
If the string is not the correct size to satisfy the requested
`dtype` and `count`.

See Also
--------
frombuffer, fromfile, fromiter
 Examples
--------
>>> np.fromstring('1 2', dtype=int, sep=' ')
array([1, 2])
>>> np.fromstring('1, 2', dtype=int, sep=',')
array([1, 2])

full(shape, fill_value, dtype=None, order='C', *, like=None)

Return a new array of given shape and type, filled with `fill_value`.

Parameters
----------
shape : int or sequence of ints
Shape of the new array, e.g., ``(2, 3)`` or ``2``.
fill_value : scalar or array_like
Fill value.
dtype : data-type, optional
The desired data-type for the array The default, None, means
``np.array(fill_value).dtype``.
order : {'C', 'F'}, optional
Whether to store multidimensional data in C- or Fortran-contiguous
(row- or column-wise) order in memory.
like : array_like, optional
Reference object to allow the creation of arrays which are not
NumPy arrays. If an array-like passed in as ``like`` supports
the ``__array_function__`` protocol, the result will be defined
by it. In this case, it ensures the creation of an array object
compatible with that passed in via this argument.

.. versionadded:: 1.20.0

Returns
-------
out : ndarray
Array of `fill_value` with the given shape, dtype, and order.

See Also
--------
full_like : Return a new array with shape of input filled with value.
empty : Return a new uninitialized array.
ones : Return a new array setting values to one.
zeros : Return a new array setting values to zero.

Examples
--------
>>> np.full((2, 2), np.inf)
array([[inf, inf],
[inf, inf]])
>>> np.full((2, 2), 10)
array([[10, 10],
[10, 10]])

>>> np.full((2, 2), [1, 2])

array([[1, 2],
[1, 2]])

full_like(a, fill_value, dtype=None, order='K', subok=True, shape=None)

Return a full array with the same shape and type as a given array.
Parameters
----------
a : array_like
The shape and data-type of `a` define these same attributes of
the returned array.
fill_value : array_like
Fill value.
dtype : data-type, optional
Overrides the data type of the result.
order : {'C', 'F', 'A', or 'K'}, optional
Overrides the memory layout of the result. '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.
subok : bool, optional.
If True, then the newly created array will use the sub-class
type of `a`, otherwise it will be a base-class array. Defaults
to True.
shape : int or sequence of ints, optional.
Overrides the shape of the result. If order='K' and the number of
dimensions is unchanged, will try to keep order, otherwise,
order='C' is implied.

.. versionadded:: 1.17.0

Returns
-------
out : ndarray
Array of `fill_value` with the same shape and type as `a`.

See Also
--------
empty_like : Return an empty array with shape and type of input.
ones_like : Return an array of ones with shape and type of input.
zeros_like : Return an array of zeros with shape and type of input.
full : Return a new array of given shape filled with value.

Examples
--------
>>> x = np.arange(6, dtype=int)
>>> np.full_like(x, 1)
array([1, 1, 1, 1, 1, 1])
>>> np.full_like(x, 0.1)
array([0, 0, 0, 0, 0, 0])
>>> np.full_like(x, 0.1, dtype=np.double)
array([0.1, 0.1, 0.1, 0.1, 0.1, 0.1])
>>> np.full_like(x, np.nan, dtype=np.double)
array([nan, nan, nan, nan, nan, nan])

>>> y = np.arange(6, dtype=np.double)

>>> np.full_like(y, 0.1)
array([0.1, 0.1, 0.1, 0.1, 0.1, 0.1])

>>> y = np.zeros([2, 2, 3], dtype=int)

>>> np.full_like(y, [0, 0, 255])
array([[[ 0, 0, 255],
[ 0, 0, 255]],
[[ 0, 0, 255],
 [ 0, 0, 255]]])

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', *, ndmin=0, like=None)
Load data from a text file, with missing values handled as specified.

Each line past the first `skip_header` lines is split at the `delimiter`
character, and characters following the `comments` character are discarded.

Parameters
----------
fname : file, str, pathlib.Path, list of str, generator
File, filename, list, or generator to read. If the filename
extension is ``.gz`` or ``.bz2``, the file is first decompressed. Note
that generators must return bytes or strings. The strings
in a list or produced by a generator are treated as lines.
dtype : dtype, optional
Data type of the resulting array.
If None, the dtypes will be determined by the contents of each
column, individually.
comments : str, optional
The character used to indicate the start of a comment.
All the characters occurring on a line after a comment are discarded.
delimiter : str, int, or sequence, optional
The string used to separate values. By default, any consecutive
whitespaces act as delimiter. An integer or sequence of integers
can also be provided as width(s) of each field.
skiprows : int, optional
`skiprows` was removed in numpy 1.10. Please use `skip_header` instead.
skip_header : int, optional
The number of lines to skip at the beginning of the file.
skip_footer : int, optional
The number of lines to skip at the end of the file.
converters : variable, optional
The set of functions that convert the data of a column to a value.
The converters can also be used to provide a default value
for missing data: ``converters = {3: lambda s: float(s or 0)}``.
missing : variable, optional
`missing` was removed in numpy 1.10. Please use `missing_values`
instead.
missing_values : variable, optional
The set of strings corresponding to missing data.
filling_values : variable, optional
The set of values to be used as default when the data are missing.
usecols : sequence, optional
Which columns to read, with 0 being the first. For example,
``usecols = (1, 4, 5)`` will extract the 2nd, 5th and 6th columns.
names : {None, True, str, sequence}, optional
If `names` is True, the field names are read from the first line after
the first `skip_header` lines. This line can optionally be preceded
by a comment delimiter. If `names` is a sequence or a single-string of
comma-separated names, the names will be used to define the field names
in a structured dtype. If `names` is None, the names of the dtype
fields will be used, if any.
excludelist : sequence, optional
 A list of names to exclude. This list is appended to the default list
['return','file','print']. Excluded names are appended with an
underscore: for example, `file` would become `file_`.
deletechars : str, optional
A string combining invalid characters that must be deleted from the
names.
defaultfmt : str, optional
A format used to define default field names, such as "f%i" or "f_%02i".
autostrip : bool, optional
Whether to automatically strip white spaces from the variables.
replace_space : char, optional
Character(s) used in replacement of white spaces in the variable
names. By default, use a '_'.
case_sensitive : {True, False, 'upper', 'lower'}, optional
If True, field names are case sensitive.
If False or 'upper', field names are converted to upper case.
If 'lower', field names are converted to lower case.
unpack : bool, optional
If True, the returned array is transposed, so that arguments may be
unpacked using ``x, y, z = genfromtxt(...)``. When used with a
structured data-type, arrays are returned for each field.
Default is False.
usemask : bool, optional
If True, return a masked array.
If False, return a regular array.
loose : bool, optional
If True, do not raise errors for invalid values.
invalid_raise : bool, optional
If True, an exception is raised if an inconsistency is detected in the
number of columns.
If False, a warning is emitted and the offending lines are skipped.
max_rows : int, optional
The maximum number of rows to read. Must not be used with skip_footer
at the same time. If given, the value must be at least 1. Default is
to read the entire file.

.. versionadded:: 1.10.0
encoding : str, optional
Encoding used to decode the inputfile. Does not apply when `fname` is
a file object. The special value 'bytes' enables backward
compatibility
workarounds that ensure that you receive byte arrays when possible
and passes latin1 encoded strings to converters. Override this value to
receive unicode arrays and pass strings as input to converters. If set
to None the system default is used. The default value is 'bytes'.

.. versionadded:: 1.14.0
ndmin : int, optional
Same parameter as `loadtxt`

.. versionadded:: 1.23.0
like : array_like, optional
Reference object to allow the creation of arrays which are not
NumPy arrays. If an array-like passed in as ``like`` supports
the ``__array_function__`` protocol, the result will be defined
by it. In this case, it ensures the creation of an array object
compatible with that passed in via this argument.

.. versionadded:: 1.20.0
 Returns
-------
out : ndarray
Data read from the text file. If `usemask` is True, this is a
masked array.

See Also
--------
numpy.loadtxt : equivalent function when no data is missing.

Notes
-----
* When spaces are used as delimiters, or when no delimiter has been given
as input, there should not be any missing data between two fields.
* When the variables are named (either by a flexible dtype or with
`names`),
there must not be any header in the file (else a ValueError
exception is raised).
* Individual values are not stripped of spaces by default.
When using a custom converter, make sure the function does remove spaces.

References
----------
.. [1] NumPy User Guide, section `I/O with NumPy
<https://docs.scipy.org/doc/numpy/user/basics.io.genfromtxt.html>`_.

Examples
--------
>>> from io import StringIO
>>> import numpy as np

Comma delimited file with mixed dtype

>>> s = StringIO(u"1,1.3,abcde")
>>> data = np.genfromtxt(s, dtype=[('myint','i8'),('myfloat','f8'),
... ('mystring','S5')], delimiter=",")
>>> data
array((1, 1.3, b'abcde'),
dtype=[('myint', '<i8'), ('myfloat', '<f8'), ('mystring', 'S5')])

Using dtype = None

>>> _ = s.seek(0) # needed for StringIO example only

>>> data = np.genfromtxt(s, dtype=None,
... names = ['myint','myfloat','mystring'], delimiter=",")
>>> data
array((1, 1.3, b'abcde'),
dtype=[('myint', '<i8'), ('myfloat', '<f8'), ('mystring', 'S5')])

Specifying dtype and names

>>> _ = s.seek(0)
>>> data = np.genfromtxt(s, dtype="i8,f8,S5",
... names=['myint','myfloat','mystring'], delimiter=",")
>>> data
array((1, 1.3, b'abcde'),
dtype=[('myint', '<i8'), ('myfloat', '<f8'), ('mystring', 'S5')])
 An example with fixed-width columns

>>> s = StringIO(u"11.3abcde")
>>> data = np.genfromtxt(s, dtype=None, names=['intvar','fltvar','strvar'],
... delimiter=[1,3,5])
>>> data
array((1, 1.3, b'abcde'),
dtype=[('intvar', '<i8'), ('fltvar', '<f8'), ('strvar', 'S5')])

An example to show comments

>>> f = StringIO('''
... text,# of chars
... hello world,11
... numpy,5''')
>>> np.genfromtxt(f, dtype='S12,S12', delimiter=',')
array([(b'text', b''), (b'hello world', b'11'), (b'numpy', b'5')],
dtype=[('f0', 'S12'), ('f1', 'S12')])

geomspace(start, stop, num=50, endpoint=True, dtype=None, axis=0)

Return numbers spaced evenly on a log scale (a geometric progression).

This is similar to `logspace`, but with endpoints specified directly.

Each output sample is a constant multiple of the previous.

.. versionchanged:: 1.16.0
Non-scalar `start` and `stop` are now supported.

Parameters
----------
start : array_like
The starting value of the sequence.
stop : array_like
The final value of the sequence, unless `endpoint` is False.
In that case, ``num + 1`` values are spaced over the
interval in log-space, of which all but the last (a sequence of
length `num`) are returned.
num : integer, optional
Number of samples to generate. Default is 50.
endpoint : boolean, optional
If true, `stop` is the last sample. Otherwise, it is not included.
Default is True.
dtype : dtype
The type of the output array. If `dtype` is not given, the data type
is inferred from `start` and `stop`. The inferred dtype will never be
an integer; `float` is chosen even if the arguments would produce an
array of integers.
axis : int, optional
The axis in the result to store the samples. Relevant only if start
or stop are array-like. By default (0), the samples will be along a
new axis inserted at the beginning. Use -1 to get an axis at the end.

.. versionadded:: 1.16.0

Returns
-------
samples : ndarray
`num` samples, equally spaced on a log scale.
See Also
--------
logspace : Similar to geomspace, but with endpoints specified using log
and base.
linspace : Similar to geomspace, but with arithmetic instead of geometric
progression.
arange : Similar to linspace, with the step size specified instead of the
number of samples.
:ref:`how-to-partition`

Notes
-----
If the inputs or dtype are complex, the output will follow a logarithmic
spiral in the complex plane. (There are an infinite number of spirals
passing through two points; the output will follow the shortest such path.)

Examples
--------
>>> np.geomspace(1, 1000, num=4)
array([ 1., 10., 100., 1000.])
>>> np.geomspace(1, 1000, num=3, endpoint=False)
array([ 1., 10., 100.])
>>> np.geomspace(1, 1000, num=4, endpoint=False)
array([ 1. , 5.62341325, 31.6227766 , 177.827941 ])
>>> np.geomspace(1, 256, num=9)
array([ 1., 2., 4., 8., 16., 32., 64., 128., 256.])

Note that the above may not produce exact integers:

>>> np.geomspace(1, 256, num=9, dtype=int)

array([ 1, 2, 4, 7, 16, 32, 63, 127, 256])
>>> np.around(np.geomspace(1, 256, num=9)).astype(int)
array([ 1, 2, 4, 8, 16, 32, 64, 128, 256])

Negative, decreasing, and complex inputs are allowed:

>>> np.geomspace(1000, 1, num=4)

array([1000., 100., 10., 1.])
>>> np.geomspace(-1000, -1, num=4)
array([-1000., -100., -10., -1.])
>>> np.geomspace(1j, 1000j, num=4) # Straight line
array([0. +1.j, 0. +10.j, 0. +100.j, 0.+1000.j])
>>> np.geomspace(-1+0j, 1+0j, num=5) # Circle
array([-1.00000000e+00+1.22464680e-16j, -7.07106781e-01+7.07106781e-01j,
6.12323400e-17+1.00000000e+00j, 7.07106781e-01+7.07106781e-01j,
1.00000000e+00+0.00000000e+00j])

Graphical illustration of `endpoint` parameter:

>>> import matplotlib.pyplot as plt

>>> N = 10
>>> y = np.zeros(N)
>>> plt.semilogx(np.geomspace(1, 1000, N, endpoint=True), y + 1, 'o')
[<matplotlib.lines.Line2D object at 0x...>]
>>> plt.semilogx(np.geomspace(1, 1000, N, endpoint=False), y + 2, 'o')
[<matplotlib.lines.Line2D object at 0x...>]
>>> plt.axis([0.5, 2000, 0, 3])
[0.5, 2000, 0, 3]
>>> plt.grid(True, color='0.7', linestyle='-', which='both', axis='both')
 >>> plt.show()

get_array_wrap(*args)
Find the wrapper for the array with the highest priority.

In case of ties, leftmost wins. If no wrapper is found, return None

get_include()
Return the directory that contains the NumPy \*.h header files.

Extension modules that need to compile against NumPy should use this
function to locate the appropriate include directory.

Notes
-----
When using ``distutils``, for example in ``setup.py``::

import numpy as np
...
Extension('extension_name', ...
include_dirs=[np.get_include()])
...

get_printoptions()
Return the current print options.

Returns
-------
print_opts : dict
Dictionary of current print options with keys

- precision : int
- threshold : int
- edgeitems : int
- linewidth : int
- suppress : bool
- nanstr : str
- infstr : str
- formatter : dict of callables
- sign : str

For a full description of these options, see `set_printoptions`.

See Also
--------
set_printoptions, printoptions, set_string_function

getbufsize()
Return the size of the buffer used in ufuncs.

Returns
-------
getbufsize : int
Size of ufunc buffer in bytes.

geterr()
Get the current way of handling floating-point errors.

Returns
 -------
res : dict
A dictionary with keys "divide", "over", "under", and "invalid",
whose values are from the strings "ignore", "print", "log", "warn",
"raise", and "call". The keys represent possible floating-point
exceptions, and the values define how these exceptions are handled.

See Also
--------
geterrcall, seterr, seterrcall

Notes
-----
For complete documentation of the types of floating-point exceptions and
treatment options, see `seterr`.

Examples
--------
>>> np.geterr()
{'divide': 'warn', 'over': 'warn', 'under': 'ignore', 'invalid': 'warn'}
>>> np.arange(3.) / np.arange(3.)
array([nan, 1., 1.])

>>> oldsettings = np.seterr(all='warn', over='raise')

>>> np.geterr()
{'divide': 'warn', 'over': 'raise', 'under': 'warn', 'invalid': 'warn'}
>>> np.arange(3.) / np.arange(3.)
array([nan, 1., 1.])

geterrcall()
Return the current callback function used on floating-point errors.

When the error handling for a floating-point error (one of "divide",

"over", "under", or "invalid") is set to 'call' or 'log', the function
that is called or the log instance that is written to is returned by
`geterrcall`. This function or log instance has been set with
`seterrcall`.

Returns
-------
errobj : callable, log instance or None
The current error handler. If no handler was set through `seterrcall`,
``None`` is returned.

See Also
--------
seterrcall, seterr, geterr

Notes
-----
For complete documentation of the types of floating-point exceptions and
treatment options, see `seterr`.

Examples
--------
>>> np.geterrcall() # we did not yet set a handler, returns None

>>> oldsettings = np.seterr(all='call')

>>> def err_handler(type, flag):
 ... print("Floating point error (%s), with flag %s" % (type, flag))
>>> oldhandler = np.seterrcall(err_handler)
>>> np.array([1, 2, 3]) / 0.0
Floating point error (divide by zero), with flag 1
array([inf, inf, inf])

>>> cur_handler = np.geterrcall()

>>> cur_handler is err_handler
True

geterrobj(...)
geterrobj()

Return the current object that defines floating-point error handling.

The error object contains all information that defines the error handling
behavior in NumPy. `geterrobj` is used internally by the other
functions that get and set error handling behavior (`geterr`, `seterr`,
`geterrcall`, `seterrcall`).

Returns
-------
errobj : list
The error object, a list containing three elements:
[internal numpy buffer size, error mask, error callback function].

The error mask is a single integer that holds the treatment information
on all four floating point errors. The information for each error type
is contained in three bits of the integer. If we print it in base 8, we
can see what treatment is set for "invalid", "under", "over", and
"divide" (in that order). The printed string can be interpreted with

* 0 : 'ignore'
* 1 : 'warn'
* 2 : 'raise'
* 3 : 'call'
* 4 : 'print'
* 5 : 'log'

See Also
--------
seterrobj, seterr, geterr, seterrcall, geterrcall
getbufsize, setbufsize

Notes
-----
For complete documentation of the types of floating-point exceptions and
treatment options, see `seterr`.

Examples
--------
>>> np.geterrobj() # first get the defaults
[8192, 521, None]

>>> def err_handler(type, flag):

... print("Floating point error (%s), with flag %s" % (type, flag))
...
>>> old_bufsize = np.setbufsize(20000)
>>> old_err = np.seterr(divide='raise')
 >>> old_handler = np.seterrcall(err_handler)
>>> np.geterrobj()
[8192, 521, <function err_handler at 0x91dcaac>]

>>> old_err = np.seterr(all='ignore')

>>> np.base_repr(np.geterrobj()[1], 8)
'0'
>>> old_err = np.seterr(divide='warn', over='log', under='call',
... invalid='print')
>>> np.base_repr(np.geterrobj()[1], 8)
'4351'

gradient(f, *varargs, axis=None, edge_order=1)

Return the gradient of an N-dimensional array.

The gradient is computed using second order accurate central differences

in the interior points and either first or second order accurate one-sides
(forward or backwards) differences at the boundaries.
The returned gradient hence has the same shape as the input array.

Parameters
----------
f : array_like
An N-dimensional array containing samples of a scalar function.
varargs : list of scalar or array, optional
Spacing between f values. Default unitary spacing for all dimensions.
Spacing can be specified using:

1. single scalar to specify a sample distance for all dimensions.

2. N scalars to specify a constant sample distance for each dimension.
i.e. `dx`, `dy`, `dz`, ...
3. N arrays to specify the coordinates of the values along each
dimension of F. The length of the array must match the size of
the corresponding dimension
4. Any combination of N scalars/arrays with the meaning of 2. and 3.

If `axis` is given, the number of varargs must equal the number of

axes.
Default: 1.

edge_order : {1, 2}, optional

Gradient is calculated using N-th order accurate differences
at the boundaries. Default: 1.

.. versionadded:: 1.9.1

axis : None or int or tuple of ints, optional

Gradient is calculated only along the given axis or axes
The default (axis = None) is to calculate the gradient for all the axes
of the input array. axis may be negative, in which case it counts from
the last to the first axis.

.. versionadded:: 1.11.0

Returns
-------
gradient : ndarray or list of ndarray
A list of ndarrays (or a single ndarray if there is only one dimension)
corresponding to the derivatives of f with respect to each dimension.
 Each derivative has the same shape as f.

Examples
--------
>>> f = np.array([1, 2, 4, 7, 11, 16], dtype=float)
>>> np.gradient(f)
array([1. , 1.5, 2.5, 3.5, 4.5, 5. ])
>>> np.gradient(f, 2)
array([0.5 , 0.75, 1.25, 1.75, 2.25, 2.5 ])

Spacing can be also specified with an array that represents the coordinates
of the values F along the dimensions.
For instance a uniform spacing:

>>> x = np.arange(f.size)
>>> np.gradient(f, x)
array([1. , 1.5, 2.5, 3.5, 4.5, 5. ])

Or a non uniform one:

>>> x = np.array([0., 1., 1.5, 3.5, 4., 6.], dtype=float)

>>> np.gradient(f, x)
array([1. , 3. , 3.5, 6.7, 6.9, 2.5])

For two dimensional arrays, the return will be two arrays ordered by
axis. In this example the first array stands for the gradient in
rows and the second one in columns direction:

>>> np.gradient(np.array([[1, 2, 6], [3, 4, 5]], dtype=float))

[array([[ 2., 2., -1.],
[ 2., 2., -1.]]), array([[1. , 2.5, 4. ],
[1. , 1. , 1. ]])]

In this example the spacing is also specified:

uniform for axis=0 and non uniform for axis=1

>>> dx = 2.
>>> y = [1., 1.5, 3.5]
>>> np.gradient(np.array([[1, 2, 6], [3, 4, 5]], dtype=float), dx, y)
[array([[ 1. , 1. , -0.5],
[ 1. , 1. , -0.5]]), array([[2. , 2. , 2. ],
[2. , 1.7, 0.5]])]

It is possible to specify how boundaries are treated using `edge_order`

>>> x = np.array([0, 1, 2, 3, 4])

>>> f = x**2
>>> np.gradient(f, edge_order=1)
array([1., 2., 4., 6., 7.])
>>> np.gradient(f, edge_order=2)
array([0., 2., 4., 6., 8.])

The `axis` keyword can be used to specify a subset of axes of which the
gradient is calculated

>>> np.gradient(np.array([[1, 2, 6], [3, 4, 5]], dtype=float), axis=0)

array([[ 2., 2., -1.],
[ 2., 2., -1.]])
Notes
-----
Assuming that :math:`f\in C^{3}` (i.e., :math:`f` has at least 3 continuous
derivatives) and let :math:`h_{*}` be a non-homogeneous stepsize, we
minimize the "consistency error" :math:`\eta_{i}` between the true gradient
and its estimate from a linear combination of the neighboring grid-points:

.. math::

\eta_{i} = f_{i}^{\left(1\right)} -
\left[ \alpha f\left(x_{i}\right) +
\beta f\left(x_{i} + h_{d}\right) +
\gamma f\left(x_{i}-h_{s}\right)
\right]

By substituting :math:`f(x_{i} + h_{d})` and :math:`f(x_{i} - h_{s})`

with their Taylor series expansion, this translates into solving
the following the linear system:

.. math::

\left\{
\begin{array}{r}
\alpha+\beta+\gamma=0 \\
\beta h_{d}-\gamma h_{s}=1 \\
\beta h_{d}^{2}+\gamma h_{s}^{2}=0
\end{array}
\right.

The resulting approximation of :math:`f_{i}^{(1)}` is the following:

.. math::

\hat f_{i}^{(1)} =
\frac{
h_{s}^{2}f\left(x_{i} + h_{d}\right)
+ \left(h_{d}^{2} - h_{s}^{2}\right)f\left(x_{i}\right)
- h_{d}^{2}f\left(x_{i}-h_{s}\right)}
{ h_{s}h_{d}\left(h_{d} + h_{s}\right)}
+ \mathcal{O}\left(\frac{h_{d}h_{s}^{2}
+ h_{s}h_{d}^{2}}{h_{d}
+ h_{s}}\right)

It is worth noting that if :math:`h_{s}=h_{d}`

(i.e., data are evenly spaced)
we find the standard second order approximation:

.. math::

\hat f_{i}^{(1)}=
\frac{f\left(x_{i+1}\right) - f\left(x_{i-1}\right)}{2h}
+ \mathcal{O}\left(h^{2}\right)

With a similar procedure the forward/backward approximations used for

boundaries can be derived.

References
----------
.. [1] Quarteroni A., Sacco R., Saleri F. (2007) Numerical Mathematics
 (Texts in Applied Mathematics). New York: Springer.
.. [2] Durran D. R. (1999) Numerical Methods for Wave Equations
in Geophysical Fluid Dynamics. New York: Springer.
.. [3] Fornberg B. (1988) Generation of Finite Difference Formulas on
Arbitrarily Spaced Grids,
Mathematics of Computation 51, no. 184 : 699-706.
`PDF <http://www.ams.org/journals/mcom/1988-51-184/
S0025-5718-1988-0935077-0/S0025-5718-1988-0935077-0.pdf>`_.

hamming(M)
Return the Hamming window.

The Hamming window is a taper formed by using a weighted cosine.

Parameters
----------
M : int
Number of points in the output window. If zero or less, an
empty array is returned.

Returns
-------
out : ndarray
The window, with the maximum value normalized to one (the value
one appears only if the number of samples is odd).

See Also
--------
bartlett, blackman, hanning, kaiser

Notes
-----
The Hamming window is defined as

.. math:: w(n) = 0.54 - 0.46\cos\left(\frac{2\pi{n}}{M-1}\right)

\qquad 0 \leq n \leq M-1

The Hamming was named for R. W. Hamming, an associate of J. W. Tukey

and is described in Blackman and Tukey. It was recommended for
smoothing the truncated autocovariance function in the time domain.
Most references to the Hamming window come from the signal processing
literature, where it is used as one of many windowing functions for
smoothing values. It is also known as an apodization (which means
"removing the foot", i.e. smoothing discontinuities at the beginning
and end of the sampled signal) or tapering function.

References
----------
.. [1] Blackman, R.B. and Tukey, J.W., (1958) The measurement of power
spectra, Dover Publications, New York.
.. [2] E.R. Kanasewich, "Time Sequence Analysis in Geophysics", The
University of Alberta Press, 1975, pp. 109-110.
.. [3] Wikipedia, "Window function",
https://en.wikipedia.org/wiki/Window_function
.. [4] W.H. Press, B.P. Flannery, S.A. Teukolsky, and W.T. Vetterling,
"Numerical Recipes", Cambridge University Press, 1986, page 425.

Examples
--------
 >>> np.hamming(12)
array([ 0.08 , 0.15302337, 0.34890909, 0.60546483, 0.84123594, #
may vary
0.98136677, 0.98136677, 0.84123594, 0.60546483, 0.34890909,
0.15302337, 0.08 ])

Plot the window and the frequency response:

>>> import matplotlib.pyplot as plt

>>> from numpy.fft import fft, fftshift
>>> window = np.hamming(51)
>>> plt.plot(window)
[<matplotlib.lines.Line2D object at 0x...>]
>>> plt.title("Hamming window")
Text(0.5, 1.0, 'Hamming window')
>>> plt.ylabel("Amplitude")
Text(0, 0.5, 'Amplitude')
>>> plt.xlabel("Sample")
Text(0.5, 0, 'Sample')
>>> plt.show()

>>> plt.figure()
<Figure size 640x480 with 0 Axes>
>>> A = fft(window, 2048) / 25.5
>>> mag = np.abs(fftshift(A))
>>> freq = np.linspace(-0.5, 0.5, len(A))
>>> response = 20 * np.log10(mag)
>>> response = np.clip(response, -100, 100)
>>> plt.plot(freq, response)
[<matplotlib.lines.Line2D object at 0x...>]
>>> plt.title("Frequency response of Hamming window")
Text(0.5, 1.0, 'Frequency response of Hamming window')
>>> plt.ylabel("Magnitude [dB]")
Text(0, 0.5, 'Magnitude [dB]')
>>> plt.xlabel("Normalized frequency [cycles per sample]")
Text(0.5, 0, 'Normalized frequency [cycles per sample]')
>>> plt.axis('tight')
...
>>> plt.show()

hanning(M)
Return the Hanning window.

The Hanning window is a taper formed by using a weighted cosine.

Parameters
----------
M : int
Number of points in the output window. If zero or less, an
empty array is returned.

Returns
-------
out : ndarray, shape(M,)
The window, with the maximum value normalized to one (the value
one appears only if `M` is odd).

See Also
--------
bartlett, blackman, hamming, kaiser

Notes
-----
The Hanning window is defined as

.. math:: w(n) = 0.5 - 0.5\cos\left(\frac{2\pi{n}}{M-1}\right)

\qquad 0 \leq n \leq M-1

The Hanning was named for Julius von Hann, an Austrian meteorologist.
It is also known as the Cosine Bell. Some authors prefer that it be
called a Hann window, to help avoid confusion with the very similar
Hamming window.

Most references to the Hanning window come from the signal processing
literature, where it is used as one of many windowing functions for
smoothing values. It is also known as an apodization (which means
"removing the foot", i.e. smoothing discontinuities at the beginning
and end of the sampled signal) or tapering function.

References
----------
.. [1] Blackman, R.B. and Tukey, J.W., (1958) The measurement of power
spectra, Dover Publications, New York.
.. [2] E.R. Kanasewich, "Time Sequence Analysis in Geophysics",
The University of Alberta Press, 1975, pp. 106-108.
.. [3] Wikipedia, "Window function",
https://en.wikipedia.org/wiki/Window_function
.. [4] W.H. Press, B.P. Flannery, S.A. Teukolsky, and W.T. Vetterling,
"Numerical Recipes", Cambridge University Press, 1986, page 425.

Examples
--------
>>> np.hanning(12)
array([0. , 0.07937323, 0.29229249, 0.57115742, 0.82743037,
0.97974649, 0.97974649, 0.82743037, 0.57115742, 0.29229249,
0.07937323, 0. ])

Plot the window and its frequency response:

>>> import matplotlib.pyplot as plt

>>> from numpy.fft import fft, fftshift
>>> window = np.hanning(51)
>>> plt.plot(window)
[<matplotlib.lines.Line2D object at 0x...>]
>>> plt.title("Hann window")
Text(0.5, 1.0, 'Hann window')
>>> plt.ylabel("Amplitude")
Text(0, 0.5, 'Amplitude')
>>> plt.xlabel("Sample")
Text(0.5, 0, 'Sample')
>>> plt.show()

>>> plt.figure()
<Figure size 640x480 with 0 Axes>
>>> A = fft(window, 2048) / 25.5
>>> mag = np.abs(fftshift(A))
>>> freq = np.linspace(-0.5, 0.5, len(A))
>>> with np.errstate(divide='ignore', invalid='ignore'):
 ... response = 20 * np.log10(mag)
...
>>> response = np.clip(response, -100, 100)
>>> plt.plot(freq, response)
[<matplotlib.lines.Line2D object at 0x...>]
>>> plt.title("Frequency response of the Hann window")
Text(0.5, 1.0, 'Frequency response of the Hann window')
>>> plt.ylabel("Magnitude [dB]")
Text(0, 0.5, 'Magnitude [dB]')
>>> plt.xlabel("Normalized frequency [cycles per sample]")
Text(0.5, 0, 'Normalized frequency [cycles per sample]')
>>> plt.axis('tight')
...
>>> plt.show()

histogram(a, bins=10, range=None, density=None, weights=None)

Compute the histogram of a dataset.

Parameters
----------
a : array_like
Input data. The histogram is computed over the flattened array.
bins : int or sequence of scalars or str, optional
If `bins` is an int, it defines the number of equal-width
bins in the given range (10, by default). If `bins` is a
sequence, it defines a monotonically increasing array of bin edges,
including the rightmost edge, allowing for non-uniform bin widths.

.. versionadded:: 1.11.0

If `bins` is a string, it defines the method used to calculate the

optimal bin width, as defined by `histogram_bin_edges`.

range : (float, float), optional

The lower and upper range of the bins. If not provided, range
is simply ``(a.min(), a.max())``. Values outside the range are
ignored. The first element of the range must be less than or
equal to the second. `range` affects the automatic bin
computation as well. While bin width is computed to be optimal
based on the actual data within `range`, the bin count will fill
the entire range including portions containing no data.
weights : array_like, optional
An array of weights, of the same shape as `a`. Each value in
`a` only contributes its associated weight towards the bin count
(instead of 1). If `density` is True, the weights are
normalized, so that the integral of the density over the range
remains 1.
density : bool, optional
If ``False``, the result will contain the number of samples in
each bin. If ``True``, the result is the value of the
probability *density* function at the bin, normalized such that
the *integral* over the range is 1. Note that the sum of the
histogram values will not be equal to 1 unless bins of unity
width are chosen; it is not a probability *mass* function.

Returns
-------
hist : array
The values of the histogram. See `density` and `weights` for a
 description of the possible semantics.
bin_edges : array of dtype float
Return the bin edges ``(length(hist)+1)``.

See Also
--------
histogramdd, bincount, searchsorted, digitize, histogram_bin_edges

Notes
-----
All but the last (righthand-most) bin is half-open. In other words,
if `bins` is::

[1, 2, 3, 4]

then the first bin is ``[1, 2)`` (including 1, but excluding 2) and
the second ``[2, 3)``. The last bin, however, is ``[3, 4]``, which
*includes* 4.

Examples
--------
>>> np.histogram([1, 2, 1], bins=[0, 1, 2, 3])
(array([0, 2, 1]), array([0, 1, 2, 3]))
>>> np.histogram(np.arange(4), bins=np.arange(5), density=True)
(array([0.25, 0.25, 0.25, 0.25]), array([0, 1, 2, 3, 4]))
>>> np.histogram([[1, 2, 1], [1, 0, 1]], bins=[0,1,2,3])
(array([1, 4, 1]), array([0, 1, 2, 3]))

>>> a = np.arange(5)
>>> hist, bin_edges = np.histogram(a, density=True)
>>> hist
array([0.5, 0. , 0.5, 0. , 0. , 0.5, 0. , 0.5, 0. , 0.5])
>>> hist.sum()
2.4999999999999996
>>> np.sum(hist * np.diff(bin_edges))
1.0

.. versionadded:: 1.11.0

Automated Bin Selection Methods example, using 2 peak random data

with 2000 points:

>>> import matplotlib.pyplot as plt

>>> rng = np.random.RandomState(10) # deterministic random data
>>> a = np.hstack((rng.normal(size=1000),
... rng.normal(loc=5, scale=2, size=1000)))
>>> _ = plt.hist(a, bins='auto') # arguments are passed to np.histogram
>>> plt.title("Histogram with 'auto' bins")
Text(0.5, 1.0, "Histogram with 'auto' bins")
>>> plt.show()

histogram2d(x, y, bins=10, range=None, density=None, weights=None)

Compute the bi-dimensional histogram of two data samples.

Parameters
----------
x : array_like, shape (N,)
 An array containing the x coordinates of the points to be
histogrammed.
y : array_like, shape (N,)
An array containing the y coordinates of the points to be
histogrammed.
bins : int or array_like or [int, int] or [array, array], optional
The bin specification:

* If int, the number of bins for the two dimensions (nx=ny=bins).

* If array_like, the bin edges for the two dimensions
(x_edges=y_edges=bins).
* If [int, int], the number of bins in each dimension
(nx, ny = bins).
* If [array, array], the bin edges in each dimension
(x_edges, y_edges = bins).
* A combination [int, array] or [array, int], where int
is the number of bins and array is the bin edges.

range : array_like, shape(2,2), optional

The leftmost and rightmost edges of the bins along each dimension
(if not specified explicitly in the `bins` parameters):
``[[xmin, xmax], [ymin, ymax]]``. All values outside of this range
will be considered outliers and not tallied in the histogram.
density : bool, optional
If False, the default, returns the number of samples in each bin.
If True, returns the probability *density* function at the bin,
``bin_count / sample_count / bin_area``.
weights : array_like, shape(N,), optional
An array of values ``w_i`` weighing each sample ``(x_i, y_i)``.
Weights are normalized to 1 if `density` is True. If `density` is
False, the values of the returned histogram are equal to the sum of
the weights belonging to the samples falling into each bin.

Returns
-------
H : ndarray, shape(nx, ny)
The bi-dimensional histogram of samples `x` and `y`. Values in `x`
are histogrammed along the first dimension and values in `y` are
histogrammed along the second dimension.
xedges : ndarray, shape(nx+1,)
The bin edges along the first dimension.
yedges : ndarray, shape(ny+1,)
The bin edges along the second dimension.

See Also
--------
histogram : 1D histogram
histogramdd : Multidimensional histogram

Notes
-----
When `density` is True, then the returned histogram is the sample
density, defined such that the sum over bins of the product
``bin_value * bin_area`` is 1.

Please note that the histogram does not follow the Cartesian convention
where `x` values are on the abscissa and `y` values on the ordinate
axis. Rather, `x` is histogrammed along the first dimension of the
array (vertical), and `y` along the second dimension of the array
(horizontal). This ensures compatibility with `histogramdd`.

Examples
--------
>>> from matplotlib.image import NonUniformImage
>>> import matplotlib.pyplot as plt

Construct a 2-D histogram with variable bin width. First define the bin
edges:

>>> xedges = [0, 1, 3, 5]

>>> yedges = [0, 2, 3, 4, 6]

Next we create a histogram H with random bin content:

>>> x = np.random.normal(2, 1, 100)

>>> y = np.random.normal(1, 1, 100)
>>> H, xedges, yedges = np.histogram2d(x, y, bins=(xedges, yedges))
>>> # Histogram does not follow Cartesian convention (see Notes),
>>> # therefore transpose H for visualization purposes.
>>> H = H.T

:func:`imshow <matplotlib.pyplot.imshow>` can only display square bins:

>>> fig = plt.figure(figsize=(7, 3))

>>> ax = fig.add_subplot(131, title='imshow: square bins')
>>> plt.imshow(H, interpolation='nearest', origin='lower',
... extent=[xedges[0], xedges[-1], yedges[0], yedges[-1]])
<matplotlib.image.AxesImage object at 0x...>

:func:`pcolormesh <matplotlib.pyplot.pcolormesh>` can display actual edges:

>>> ax = fig.add_subplot(132, title='pcolormesh: actual edges',

... aspect='equal')
>>> X, Y = np.meshgrid(xedges, yedges)
>>> ax.pcolormesh(X, Y, H)
<matplotlib.collections.QuadMesh object at 0x...>

:class:`NonUniformImage <matplotlib.image.NonUniformImage>` can be used to

display actual bin edges with interpolation:

>>> ax = fig.add_subplot(133, title='NonUniformImage: interpolated',

... aspect='equal', xlim=xedges[[0, -1]], ylim=yedges[[0, -1]])
>>> im = NonUniformImage(ax, interpolation='bilinear')
>>> xcenters = (xedges[:-1] + xedges[1:]) / 2
>>> ycenters = (yedges[:-1] + yedges[1:]) / 2
>>> im.set_data(xcenters, ycenters, H)
>>> ax.add_image(im)
>>> plt.show()

It is also possible to construct a 2-D histogram without specifying bin

edges:

>>> # Generate non-symmetric test data

>>> n = 10000
>>> x = np.linspace(1, 100, n)
>>> y = 2*np.log(x) + np.random.rand(n) - 0.5
>>> # Compute 2d histogram. Note the order of x/y and xedges/yedges
>>> H, yedges, xedges = np.histogram2d(y, x, bins=20)
 Now we can plot the histogram using
:func:`pcolormesh <matplotlib.pyplot.pcolormesh>`, and a
:func:`hexbin <matplotlib.pyplot.hexbin>` for comparison.

>>> # Plot histogram using pcolormesh

>>> fig, (ax1, ax2) = plt.subplots(ncols=2, sharey=True)
>>> ax1.pcolormesh(xedges, yedges, H, cmap='rainbow')
>>> ax1.plot(x, 2*np.log(x), 'k-')
>>> ax1.set_xlim(x.min(), x.max())
>>> ax1.set_ylim(y.min(), y.max())
>>> ax1.set_xlabel('x')
>>> ax1.set_ylabel('y')
>>> ax1.set_title('histogram2d')
>>> ax1.grid()

>>> # Create hexbin plot for comparison

>>> ax2.hexbin(x, y, gridsize=20, cmap='rainbow')
>>> ax2.plot(x, 2*np.log(x), 'k-')
>>> ax2.set_title('hexbin')
>>> ax2.set_xlim(x.min(), x.max())
>>> ax2.set_xlabel('x')
>>> ax2.grid()

>>> plt.show()

histogram_bin_edges(a, bins=10, range=None, weights=None)

Function to calculate only the edges of the bins used by the `histogram`
function.

Parameters
----------
a : array_like
Input data. The histogram is computed over the flattened array.
bins : int or sequence of scalars or str, optional
If `bins` is an int, it defines the number of equal-width
bins in the given range (10, by default). If `bins` is a
sequence, it defines the bin edges, including the rightmost
edge, allowing for non-uniform bin widths.

If `bins` is a string from the list below, `histogram_bin_edges` will

use
the method chosen to calculate the optimal bin width and
consequently the number of bins (see `Notes` for more detail on
the estimators) from the data that falls within the requested
range. While the bin width will be optimal for the actual data
in the range, the number of bins will be computed to fill the
entire range, including the empty portions. For visualisation,
using the 'auto' option is suggested. Weighted data is not
supported for automated bin size selection.

'auto'
Maximum of the 'sturges' and 'fd' estimators. Provides good
all around performance.

'fd' (Freedman Diaconis Estimator)

Robust (resilient to outliers) estimator that takes into
account data variability and data size.
 'doane'
An improved version of Sturges' estimator that works better
with non-normal datasets.

'scott'
Less robust estimator that takes into account data variability
and data size.

'stone'
Estimator based on leave-one-out cross-validation estimate of
the integrated squared error. Can be regarded as a generalization
of Scott's rule.

'rice'
Estimator does not take variability into account, only data
size. Commonly overestimates number of bins required.

'sturges'
R's default method, only accounts for data size. Only
optimal for gaussian data and underestimates number of bins
for large non-gaussian datasets.

'sqrt'
Square root (of data size) estimator, used by Excel and
other programs for its speed and simplicity.

range : (float, float), optional

The lower and upper range of the bins. If not provided, range
is simply ``(a.min(), a.max())``. Values outside the range are
ignored. The first element of the range must be less than or
equal to the second. `range` affects the automatic bin
computation as well. While bin width is computed to be optimal
based on the actual data within `range`, the bin count will fill
the entire range including portions containing no data.

weights : array_like, optional

An array of weights, of the same shape as `a`. Each value in
`a` only contributes its associated weight towards the bin count
(instead of 1). This is currently not used by any of the bin
estimators,
but may be in the future.

Returns
-------
bin_edges : array of dtype float
The edges to pass into `histogram`

See Also
--------
histogram

Notes
-----
The methods to estimate the optimal number of bins are well founded
in literature, and are inspired by the choices R provides for
histogram visualisation. Note that having the number of bins
proportional to :math:`n^{1/3}` is asymptotically optimal, which is
why it appears in most estimators. These are simply plug-in methods
that give good starting points for number of bins. In the equations
below, :math:`h` is the binwidth and :math:`n_h` is the number of
bins. All estimators that compute bin counts are recast to bin width
using the `ptp` of the data. The final bin count is obtained from
``np.round(np.ceil(range / h))``. The final bin width is often less
than what is returned by the estimators below.

'auto' (maximum of the 'sturges' and 'fd' estimators)

A compromise to get a good value. For small datasets the Sturges
value will usually be chosen, while larger datasets will usually
default to FD. Avoids the overly conservative behaviour of FD
and Sturges for small and large datasets respectively.
Switchover point is usually :math:`a.size \approx 1000`.

'fd' (Freedman Diaconis Estimator)

.. math:: h = 2 \frac{IQR}{n^{1/3}}

The binwidth is proportional to the interquartile range (IQR)

and inversely proportional to cube root of a.size. Can be too
conservative for small datasets, but is quite good for large
datasets. The IQR is very robust to outliers.

'scott'
.. math:: h = \sigma \sqrt[3]{\frac{24 \sqrt{\pi}}{n}}

The binwidth is proportional to the standard deviation of the

data and inversely proportional to cube root of ``x.size``. Can
be too conservative for small datasets, but is quite good for
large datasets. The standard deviation is not very robust to
outliers. Values are very similar to the Freedman-Diaconis
estimator in the absence of outliers.

'rice'
.. math:: n_h = 2n^{1/3}

The number of bins is only proportional to cube root of

``a.size``. It tends to overestimate the number of bins and it
does not take into account data variability.

'sturges'
.. math:: n_h = \log _{2}(n) + 1

The number of bins is the base 2 log of ``a.size``. This

estimator assumes normality of data and is too conservative for
larger, non-normal datasets. This is the default method in R's
``hist`` method.

'doane'
.. math:: n_h = 1 + \log_{2}(n) +
\log_{2}\left(1 + \frac{|g_1|}{\sigma_{g_1}}\right)

g_1 = mean\left[\left(\frac{x - \mu}{\sigma}\right)^3\right]

\sigma_{g_1} = \sqrt{\frac{6(n - 2)}{(n + 1)(n + 3)}}

An improved version of Sturges' formula that produces better

estimates for non-normal datasets. This estimator attempts to
account for the skew of the data.

'sqrt'
 .. math:: n_h = \sqrt n

The simplest and fastest estimator. Only takes into account the
data size.

Examples
--------
>>> arr = np.array([0, 0, 0, 1, 2, 3, 3, 4, 5])
>>> np.histogram_bin_edges(arr, bins='auto', range=(0, 1))
array([0. , 0.25, 0.5 , 0.75, 1. ])
>>> np.histogram_bin_edges(arr, bins=2)
array([0. , 2.5, 5. ])

For consistency with histogram, an array of pre-computed bins is

passed through unmodified:

>>> np.histogram_bin_edges(arr, [1, 2])

array([1, 2])

This function allows one set of bins to be computed, and reused across
multiple histograms:

>>> shared_bins = np.histogram_bin_edges(arr, bins='auto')

>>> shared_bins
array([0., 1., 2., 3., 4., 5.])

>>> group_id = np.array([0, 1, 1, 0, 1, 1, 0, 1, 1])

>>> hist_0, _ = np.histogram(arr[group_id == 0], bins=shared_bins)
>>> hist_1, _ = np.histogram(arr[group_id == 1], bins=shared_bins)

>>> hist_0; hist_1

array([1, 1, 0, 1, 0])
array([2, 0, 1, 1, 2])

Which gives more easily comparable results than using separate bins for
each histogram:

>>> hist_0, bins_0 = np.histogram(arr[group_id == 0], bins='auto')

>>> hist_1, bins_1 = np.histogram(arr[group_id == 1], bins='auto')
>>> hist_0; hist_1
array([1, 1, 1])
array([2, 1, 1, 2])
>>> bins_0; bins_1
array([0., 1., 2., 3.])
array([0. , 1.25, 2.5 , 3.75, 5. ])

histogramdd(sample, bins=10, range=None, density=None, weights=None)

Compute the multidimensional histogram of some data.

Parameters
----------
sample : (N, D) array, or (N, D) array_like
The data to be histogrammed.

Note the unusual interpretation of sample when an array_like:

* When an array, each row is a coordinate in a D-dimensional space -

such as ``histogramdd(np.array([p1, p2, p3]))``.
* When an array_like, each element is the list of values for single
 coordinate - such as ``histogramdd((X, Y, Z))``.

The first form should be preferred.

bins : sequence or int, optional

The bin specification:

* A sequence of arrays describing the monotonically increasing bin

edges along each dimension.
* The number of bins for each dimension (nx, ny, ... =bins)
* The number of bins for all dimensions (nx=ny=...=bins).

range : sequence, optional

A sequence of length D, each an optional (lower, upper) tuple giving
the outer bin edges to be used if the edges are not given explicitly in
`bins`.
An entry of None in the sequence results in the minimum and maximum
values being used for the corresponding dimension.
The default, None, is equivalent to passing a tuple of D None values.
density : bool, optional
If False, the default, returns the number of samples in each bin.
If True, returns the probability *density* function at the bin,
``bin_count / sample_count / bin_volume``.
weights : (N,) array_like, optional
An array of values `w_i` weighing each sample `(x_i, y_i, z_i, ...)`.
Weights are normalized to 1 if density is True. If density is False,
the values of the returned histogram are equal to the sum of the
weights belonging to the samples falling into each bin.

Returns
-------
H : ndarray
The multidimensional histogram of sample x. See density and weights
for the different possible semantics.
edges : list
A list of D arrays describing the bin edges for each dimension.

See Also
--------
histogram: 1-D histogram
histogram2d: 2-D histogram

Examples
--------
>>> r = np.random.randn(100,3)
>>> H, edges = np.histogramdd(r, bins = (5, 8, 4))
>>> H.shape, edges[0].size, edges[1].size, edges[2].size
((5, 8, 4), 6, 9, 5)

hsplit(ary, indices_or_sections)
Split an array into multiple sub-arrays horizontally (column-wise).

Please refer to the `split` documentation. `hsplit` is equivalent

to `split` with ``axis=1``, the array is always split along the second
axis except for 1-D arrays, where it is split at ``axis=0``.

See Also
--------
split : Split an array into multiple sub-arrays of equal size.
 Examples
--------
>>> x = np.arange(16.0).reshape(4, 4)
>>> x
array([[ 0., 1., 2., 3.],
[ 4., 5., 6., 7.],
[ 8., 9., 10., 11.],
[12., 13., 14., 15.]])
>>> np.hsplit(x, 2)
[array([[ 0., 1.],
[ 4., 5.],
[ 8., 9.],
[12., 13.]]),
array([[ 2., 3.],
[ 6., 7.],
[10., 11.],
[14., 15.]])]
>>> np.hsplit(x, np.array([3, 6]))
[array([[ 0., 1., 2.],
[ 4., 5., 6.],
[ 8., 9., 10.],
[12., 13., 14.]]),
array([[ 3.],
[ 7.],
[11.],
[15.]]),
array([], shape=(4, 0), dtype=float64)]

With a higher dimensional array the split is still along the second axis.

>>> x = np.arange(8.0).reshape(2, 2, 2)
>>> x
array([[[0., 1.],
[2., 3.]],
[[4., 5.],
[6., 7.]]])
>>> np.hsplit(x, 2)
[array([[[0., 1.]],
[[4., 5.]]]),
array([[[2., 3.]],
[[6., 7.]]])]

With a 1-D array, the split is along axis 0.

>>> x = np.array([0, 1, 2, 3, 4, 5])

>>> np.hsplit(x, 2)
[array([0, 1, 2]), array([3, 4, 5])]

hstack(tup, *, dtype=None, casting='same_kind')

Stack arrays in sequence horizontally (column wise).

This is equivalent to concatenation along the second axis, except for 1-D
arrays where it concatenates along the first axis. Rebuilds arrays divided
by `hsplit`.

This function makes most sense for arrays with up to 3 dimensions. For
instance, for pixel-data with a height (first axis), width (second axis),
and r/g/b channels (third axis). The functions `concatenate`, `stack` and
 `block` provide more general stacking and concatenation operations.

Parameters
----------
tup : sequence of ndarrays
The arrays must have the same shape along all but the second axis,
except 1-D arrays which can be any length.

dtype : str or dtype

If provided, the destination array will have this dtype. Cannot be
provided together with `out`.

.. versionadded:: 1.24

casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional

Controls what kind of data casting may occur. Defaults to 'same_kind'.

.. versionadded:: 1.24

Returns
-------
stacked : ndarray
The array formed by stacking the given arrays.

See Also
--------
concatenate : Join a sequence of arrays along an existing axis.
stack : Join a sequence of arrays along a new axis.
block : Assemble an nd-array from nested lists of blocks.
vstack : Stack arrays in sequence vertically (row wise).
dstack : Stack arrays in sequence depth wise (along third axis).
column_stack : Stack 1-D arrays as columns into a 2-D array.
hsplit : Split an array into multiple sub-arrays horizontally (column-
wise).

Examples
--------
>>> a = np.array((1,2,3))
>>> b = np.array((4,5,6))
>>> np.hstack((a,b))
array([1, 2, 3, 4, 5, 6])
>>> a = np.array([[1],[2],[3]])
>>> b = np.array([[4],[5],[6]])
>>> np.hstack((a,b))
array([[1, 4],
[2, 5],
[3, 6]])

i0(x)
Modified Bessel function of the first kind, order 0.

Usually denoted :math:`I_0`.

Parameters
----------
x : array_like of float
Argument of the Bessel function.

Returns
 -------
out : ndarray, shape = x.shape, dtype = float
The modified Bessel function evaluated at each of the elements of `x`.

See Also
--------
scipy.special.i0, scipy.special.iv, scipy.special.ive

Notes
-----
The scipy implementation is recommended over this function: it is a
proper ufunc written in C, and more than an order of magnitude faster.

We use the algorithm published by Clenshaw [1]_ and referenced by

Abramowitz and Stegun [2]_, for which the function domain is
partitioned into the two intervals [0,8] and (8,inf), and Chebyshev
polynomial expansions are employed in each interval. Relative error on
the domain [0,30] using IEEE arithmetic is documented [3]_ as having a
peak of 5.8e-16 with an rms of 1.4e-16 (n = 30000).

References
----------
.. [1] C. W. Clenshaw, "Chebyshev series for mathematical functions", in
*National Physical Laboratory Mathematical Tables*, vol. 5, London:
Her Majesty's Stationery Office, 1962.
.. [2] M. Abramowitz and I. A. Stegun, *Handbook of Mathematical
Functions*, 10th printing, New York: Dover, 1964, pp. 379.
https://personal.math.ubc.ca/~cbm/aands/page_379.htm
.. [3]
https://metacpan.org/pod/distribution/Math-Cephes/lib/Math/Cephes.pod#i0:-Modified-
Bessel-function-of-order-zero

Examples
--------
>>> np.i0(0.)
array(1.0)
>>> np.i0([0, 1, 2, 3])
array([1. , 1.26606588, 2.2795853 , 4.88079259])

identity(n, dtype=None, *, like=None)

Return the identity array.

The identity array is a square array with ones on

the main diagonal.

Parameters
----------
n : int
Number of rows (and columns) in `n` x `n` output.
dtype : data-type, optional
Data-type of the output. Defaults to ``float``.
like : array_like, optional
Reference object to allow the creation of arrays which are not
NumPy arrays. If an array-like passed in as ``like`` supports
the ``__array_function__`` protocol, the result will be defined
by it. In this case, it ensures the creation of an array object
compatible with that passed in via this argument.

.. versionadded:: 1.20.0
 Returns
-------
out : ndarray
`n` x `n` array with its main diagonal set to one,
and all other elements 0.

Examples
--------
>>> np.identity(3)
array([[1., 0., 0.],
[0., 1., 0.],
[0., 0., 1.]])

imag(val)
Return the imaginary part of the complex argument.

Parameters
----------
val : array_like
Input array.

Returns
-------
out : ndarray or scalar
The imaginary component of the complex argument. If `val` is real,
the type of `val` is used for the output. If `val` has complex
elements, the returned type is float.

See Also
--------
real, angle, real_if_close

Examples
--------
>>> a = np.array([1+2j, 3+4j, 5+6j])
>>> a.imag
array([2., 4., 6.])
>>> a.imag = np.array([8, 10, 12])
>>> a
array([1. +8.j, 3.+10.j, 5.+12.j])
>>> np.imag(1 + 1j)
1.0

in1d(ar1, ar2, assume_unique=False, invert=False, *, kind=None)

Test whether each element of a 1-D array is also present in a second array.

Returns a boolean array the same length as `ar1` that is True

where an element of `ar1` is in `ar2` and False otherwise.

We recommend using :func:`isin` instead of `in1d` for new code.

Parameters
----------
ar1 : (M,) array_like
Input array.
ar2 : array_like
The values against which to test each value of `ar1`.
assume_unique : bool, optional
 If True, the input arrays are both assumed to be unique, which
can speed up the calculation. Default is False.
invert : bool, optional
If True, the values in the returned array are inverted (that is,
False where an element of `ar1` is in `ar2` and True otherwise).
Default is False. ``np.in1d(a, b, invert=True)`` is equivalent
to (but is faster than) ``np.invert(in1d(a, b))``.
kind : {None, 'sort', 'table'}, optional
The algorithm to use. This will not affect the final result,
but will affect the speed and memory use. The default, None,
will select automatically based on memory considerations.

* If 'sort', will use a mergesort-based approach. This will have

a memory usage of roughly 6 times the sum of the sizes of
`ar1` and `ar2`, not accounting for size of dtypes.
* If 'table', will use a lookup table approach similar
to a counting sort. This is only available for boolean and
integer arrays. This will have a memory usage of the
size of `ar1` plus the max-min value of `ar2`. `assume_unique`
has no effect when the 'table' option is used.
* If None, will automatically choose 'table' if
the required memory allocation is less than or equal to
6 times the sum of the sizes of `ar1` and `ar2`,
otherwise will use 'sort'. This is done to not use
a large amount of memory by default, even though
'table' may be faster in most cases. If 'table' is chosen,
`assume_unique` will have no effect.

.. versionadded:: 1.8.0

Returns
-------
in1d : (M,) ndarray, bool
The values `ar1[in1d]` are in `ar2`.

See Also
--------
isin : Version of this function that preserves the
shape of ar1.
numpy.lib.arraysetops : Module with a number of other functions for
performing set operations on arrays.

Notes
-----
`in1d` can be considered as an element-wise function version of the
python keyword `in`, for 1-D sequences. ``in1d(a, b)`` is roughly
equivalent to ``np.array([item in b for item in a])``.
However, this idea fails if `ar2` is a set, or similar (non-sequence)
container: As ``ar2`` is converted to an array, in those cases
``asarray(ar2)`` is an object array rather than the expected array of
contained values.

Using ``kind='table'`` tends to be faster than `kind='sort'` if the

following relationship is true:
``log10(len(ar2)) > (log10(max(ar2)-min(ar2)) - 2.27) / 0.927``,
but may use greater memory. The default value for `kind` will
be automatically selected based only on memory usage, so one may
manually set ``kind='table'`` if memory constraints can be relaxed.
 .. versionadded:: 1.4.0

Examples
--------
>>> test = np.array([0, 1, 2, 5, 0])
>>> states = [0, 2]
>>> mask = np.in1d(test, states)
>>> mask
array([ True, False, True, False, True])
>>> test[mask]
array([0, 2, 0])
>>> mask = np.in1d(test, states, invert=True)
>>> mask
array([False, True, False, True, False])
>>> test[mask]
array([1, 5])

indices(dimensions, dtype=<class 'int'>, sparse=False)

Return an array representing the indices of a grid.

Compute an array where the subarrays contain index values 0, 1, ...

varying only along the corresponding axis.

Parameters
----------
dimensions : sequence of ints
The shape of the grid.
dtype : dtype, optional
Data type of the result.
sparse : boolean, optional
Return a sparse representation of the grid instead of a dense
representation. Default is False.

.. versionadded:: 1.17

Returns
-------
grid : one ndarray or tuple of ndarrays
If sparse is False:
Returns one array of grid indices,
``grid.shape = (len(dimensions),) + tuple(dimensions)``.
If sparse is True:
Returns a tuple of arrays, with
``grid[i].shape = (1, ..., 1, dimensions[i], 1, ..., 1)`` with
dimensions[i] in the ith place

See Also
--------
mgrid, ogrid, meshgrid

Notes
-----
The output shape in the dense case is obtained by prepending the number
of dimensions in front of the tuple of dimensions, i.e. if `dimensions`
is a tuple ``(r0, ..., rN-1)`` of length ``N``, the output shape is
``(N, r0, ..., rN-1)``.

The subarrays ``grid[k]`` contains the N-D array of indices along the
``k-th`` axis. Explicitly::
 grid[k, i0, i1, ..., iN-1] = ik

Examples
--------
>>> grid = np.indices((2, 3))
>>> grid.shape
(2, 2, 3)
>>> grid[0] # row indices
array([[0, 0, 0],
[1, 1, 1]])
>>> grid[1] # column indices
array([[0, 1, 2],
[0, 1, 2]])

The indices can be used as an index into an array.

>>> x = np.arange(20).reshape(5, 4)
>>> row, col = np.indices((2, 3))
>>> x[row, col]
array([[0, 1, 2],
[4, 5, 6]])

Note that it would be more straightforward in the above example to

extract the required elements directly with ``x[:2, :3]``.

If sparse is set to true, the grid will be returned in a sparse

representation.

>>> i, j = np.indices((2, 3), sparse=True)

>>> i.shape
(2, 1)
>>> j.shape
(1, 3)
>>> i # row indices
array([[0],
[1]])
>>> j # column indices
array([[0, 1, 2]])

info(object=None, maxwidth=76, output=None, toplevel='numpy')

Get help information for an array, function, class, or module.

Parameters
----------
object : object or str, optional
Input object or name to get information about. If `object` is
an `ndarray` instance, information about the array is printed.
If `object` is a numpy object, its docstring is given. If it is
a string, available modules are searched for matching objects.
If None, information about `info` itself is returned.
maxwidth : int, optional
Printing width.
output : file like object, optional
File like object that the output is written to, default is
``None``, in which case ``sys.stdout`` will be used.
The object has to be opened in 'w' or 'a' mode.
toplevel : str, optional
Start search at this level.
 See Also
--------
source, lookfor

Notes
-----
When used interactively with an object, ``np.info(obj)`` is equivalent
to ``help(obj)`` on the Python prompt or ``obj?`` on the IPython
prompt.

Examples
--------
>>> np.info(np.polyval) # doctest: +SKIP
polyval(p, x)
Evaluate the polynomial p at x.
...

When using a string for `object` it is possible to get multiple results.

>>> np.info('fft') # doctest: +SKIP

*** Found in numpy ***
Core FFT routines
...
*** Found in numpy.fft ***
fft(a, n=None, axis=-1)
...
*** Repeat reference found in numpy.fft.fftpack ***
*** Total of 3 references found. ***

When the argument is an array, information about the array is printed.

>>> a = np.array([[1 + 2j, 3, -4], [-5j, 6, 0]], dtype=np.complex64)

>>> np.info(a)
class: ndarray
shape: (2, 3)
strides: (24, 8)
itemsize: 8
aligned: True
contiguous: True
fortran: False
data pointer: 0x562b6e0d2860 # may vary
byteorder: little
byteswap: False
type: complex64

inner(...)
inner(a, b, /)

Inner product of two arrays.

Ordinary inner product of vectors for 1-D arrays (without complex

conjugation), in higher dimensions a sum product over the last axes.

Parameters
----------
a, b : array_like
If `a` and `b` are nonscalar, their last dimensions must match.
Returns
-------
out : ndarray
If `a` and `b` are both
scalars or both 1-D arrays then a scalar is returned; otherwise
an array is returned.
``out.shape = (*a.shape[:-1], *b.shape[:-1])``

Raises
------
ValueError
If both `a` and `b` are nonscalar and their last dimensions have
different sizes.

See Also
--------
tensordot : Sum products over arbitrary axes.
dot : Generalised matrix product, using second last dimension of `b`.
einsum : Einstein summation convention.

Notes
-----
For vectors (1-D arrays) it computes the ordinary inner-product::

np.inner(a, b) = sum(a[:]*b[:])

More generally, if ``ndim(a) = r > 0`` and ``ndim(b) = s > 0``::

np.inner(a, b) = np.tensordot(a, b, axes=(-1,-1))

or explicitly::

np.inner(a, b)[i0,...,ir-2,j0,...,js-2]
= sum(a[i0,...,ir-2,:]*b[j0,...,js-2,:])

In addition `a` or `b` may be scalars, in which case::

np.inner(a,b) = a*b

Examples
--------
Ordinary inner product for vectors:

>>> a = np.array([1,2,3])
>>> b = np.array([0,1,0])
>>> np.inner(a, b)
2

Some multidimensional examples:

>>> a = np.arange(24).reshape((2,3,4))
>>> b = np.arange(4)
>>> c = np.inner(a, b)
>>> c.shape
(2, 3)
>>> c
array([[ 14, 38, 62],
[ 86, 110, 134]])
 >>> a = np.arange(2).reshape((1,1,2))
>>> b = np.arange(6).reshape((3,2))
>>> c = np.inner(a, b)
>>> c.shape
(1, 1, 3)
>>> c
array([[[1, 3, 5]]])

An example where `b` is a scalar:

>>> np.inner(np.eye(2), 7)
array([[7., 0.],
[0., 7.]])

insert(arr, obj, values, axis=None)

Insert values along the given axis before the given indices.

Parameters
----------
arr : array_like
Input array.
obj : int, slice or sequence of ints
Object that defines the index or indices before which `values` is
inserted.

.. versionadded:: 1.8.0

Support for multiple insertions when `obj` is a single scalar or a

sequence with one element (similar to calling insert multiple
times).
values : array_like
Values to insert into `arr`. If the type of `values` is different
from that of `arr`, `values` is converted to the type of `arr`.
`values` should be shaped so that ``arr[...,obj,...] = values``
is legal.
axis : int, optional
Axis along which to insert `values`. If `axis` is None then `arr`
is flattened first.

Returns
-------
out : ndarray
A copy of `arr` with `values` inserted. Note that `insert`
does not occur in-place: a new array is returned. If
`axis` is None, `out` is a flattened array.

See Also
--------
append : Append elements at the end of an array.
concatenate : Join a sequence of arrays along an existing axis.
delete : Delete elements from an array.

Notes
-----
Note that for higher dimensional inserts ``obj=0`` behaves very different
from ``obj=[0]`` just like ``arr[:,0,:] = values`` is different from
``arr[:,[0],:] = values``.

Examples
 --------
>>> a = np.array([[1, 1], [2, 2], [3, 3]])
>>> a
array([[1, 1],
[2, 2],
[3, 3]])
>>> np.insert(a, 1, 5)
array([1, 5, 1, ..., 2, 3, 3])
>>> np.insert(a, 1, 5, axis=1)
array([[1, 5, 1],
[2, 5, 2],
[3, 5, 3]])

Difference between sequence and scalars:

>>> np.insert(a, [1], [[1],[2],[3]], axis=1)

array([[1, 1, 1],
[2, 2, 2],
[3, 3, 3]])
>>> np.array_equal(np.insert(a, 1, [1, 2, 3], axis=1),
... np.insert(a, [1], [[1],[2],[3]], axis=1))
True

>>> b = a.flatten()
>>> b
array([1, 1, 2, 2, 3, 3])
>>> np.insert(b, [2, 2], [5, 6])
array([1, 1, 5, ..., 2, 3, 3])

>>> np.insert(b, slice(2, 4), [5, 6])

array([1, 1, 5, ..., 2, 3, 3])

>>> np.insert(b, [2, 2], [7.13, False]) # type casting

array([1, 1, 7, ..., 2, 3, 3])

>>> x = np.arange(8).reshape(2, 4)
>>> idx = (1, 3)
>>> np.insert(x, idx, 999, axis=1)
array([[ 0, 999, 1, 2, 999, 3],
[ 4, 999, 5, 6, 999, 7]])

interp(x, xp, fp, left=None, right=None, period=None)

One-dimensional linear interpolation for monotonically increasing sample
points.

Returns the one-dimensional piecewise linear interpolant to a function

with given discrete data points (`xp`, `fp`), evaluated at `x`.

Parameters
----------
x : array_like
The x-coordinates at which to evaluate the interpolated values.

xp : 1-D sequence of floats

The x-coordinates of the data points, must be increasing if argument
`period` is not specified. Otherwise, `xp` is internally sorted after
normalizing the periodic boundaries with ``xp = xp % period``.

fp : 1-D sequence of float or complex

 The y-coordinates of the data points, same length as `xp`.

left : optional float or complex corresponding to fp

Value to return for `x < xp[0]`, default is `fp[0]`.

right : optional float or complex corresponding to fp

Value to return for `x > xp[-1]`, default is `fp[-1]`.

period : None or float, optional

A period for the x-coordinates. This parameter allows the proper
interpolation of angular x-coordinates. Parameters `left` and `right`
are ignored if `period` is specified.

.. versionadded:: 1.10.0

Returns
-------
y : float or complex (corresponding to fp) or ndarray
The interpolated values, same shape as `x`.

Raises
------
ValueError
If `xp` and `fp` have different length
If `xp` or `fp` are not 1-D sequences
If `period == 0`

See Also
--------
scipy.interpolate

Warnings
--------
The x-coordinate sequence is expected to be increasing, but this is not
explicitly enforced. However, if the sequence `xp` is non-increasing,
interpolation results are meaningless.

Note that, since NaN is unsortable, `xp` also cannot contain NaNs.

A simple check for `xp` being strictly increasing is::

np.all(np.diff(xp) > 0)

Examples
--------
>>> xp = [1, 2, 3]
>>> fp = [3, 2, 0]
>>> np.interp(2.5, xp, fp)
1.0
>>> np.interp([0, 1, 1.5, 2.72, 3.14], xp, fp)
array([3. , 3. , 2.5 , 0.56, 0. ])
>>> UNDEF = -99.0
>>> np.interp(3.14, xp, fp, right=UNDEF)
-99.0

Plot an interpolant to the sine function:

>>> x = np.linspace(0, 2*np.pi, 10)

>>> y = np.sin(x)
 >>> xvals = np.linspace(0, 2*np.pi, 50)
>>> yinterp = np.interp(xvals, x, y)
>>> import matplotlib.pyplot as plt
>>> plt.plot(x, y, 'o')
[<matplotlib.lines.Line2D object at 0x...>]
>>> plt.plot(xvals, yinterp, '-x')
[<matplotlib.lines.Line2D object at 0x...>]
>>> plt.show()

Interpolation with periodic x-coordinates:

>>> x = [-180, -170, -185, 185, -10, -5, 0, 365]

>>> xp = [190, -190, 350, -350]
>>> fp = [5, 10, 3, 4]
>>> np.interp(x, xp, fp, period=360)
array([7.5 , 5. , 8.75, 6.25, 3. , 3.25, 3.5 , 3.75])

Complex interpolation:

>>> x = [1.5, 4.0]

>>> xp = [2,3,5]
>>> fp = [1.0j, 0, 2+3j]
>>> np.interp(x, xp, fp)
array([0.+1.j , 1.+1.5j])

intersect1d(ar1, ar2, assume_unique=False, return_indices=False)

Find the intersection of two arrays.

Return the sorted, unique values that are in both of the input arrays.

Parameters
----------
ar1, ar2 : array_like
Input arrays. Will be flattened if not already 1D.
assume_unique : bool
If True, the input arrays are both assumed to be unique, which
can speed up the calculation. If True but ``ar1`` or ``ar2`` are not
unique, incorrect results and out-of-bounds indices could result.
Default is False.
return_indices : bool
If True, the indices which correspond to the intersection of the two
arrays are returned. The first instance of a value is used if there are
multiple. Default is False.

.. versionadded:: 1.15.0

Returns
-------
intersect1d : ndarray
Sorted 1D array of common and unique elements.
comm1 : ndarray
The indices of the first occurrences of the common values in `ar1`.
Only provided if `return_indices` is True.
comm2 : ndarray
The indices of the first occurrences of the common values in `ar2`.
Only provided if `return_indices` is True.

See Also
 --------
numpy.lib.arraysetops : Module with a number of other functions for
performing set operations on arrays.

Examples
--------
>>> np.intersect1d([1, 3, 4, 3], [3, 1, 2, 1])
array([1, 3])

To intersect more than two arrays, use functools.reduce:

>>> from functools import reduce

>>> reduce(np.intersect1d, ([1, 3, 4, 3], [3, 1, 2, 1], [6, 3, 4, 2]))
array([3])

To return the indices of the values common to the input arrays

along with the intersected values:

>>> x = np.array([1, 1, 2, 3, 4])

>>> y = np.array([2, 1, 4, 6])
>>> xy, x_ind, y_ind = np.intersect1d(x, y, return_indices=True)
>>> x_ind, y_ind
(array([0, 2, 4]), array([1, 0, 2]))
>>> xy, x[x_ind], y[y_ind]
(array([1, 2, 4]), array([1, 2, 4]), array([1, 2, 4]))

is_busday(...)
is_busday(dates, weekmask='1111100', holidays=None, busdaycal=None,
out=None)

Calculates which of the given dates are valid days, and which are not.

.. versionadded:: 1.7.0

Parameters
----------
dates : array_like of datetime64[D]
The array of dates to process.
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. They 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.
busdaycal : busdaycalendar, optional
A `busdaycalendar` object which specifies the valid days. If this
parameter is provided, neither weekmask nor holidays may be
provided.
out : array of bool, optional
If provided, this array is filled with the result.

Returns
-------
 out : array of bool
An array with the same shape as ``dates``, containing True for
each valid day, and False for each invalid day.

See Also
--------
busdaycalendar : An object that specifies a custom set of 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.

Examples
--------
>>> # The weekdays are Friday, Saturday, and Monday
... np.is_busday(['2011-07-01', '2011-07-02', '2011-07-18'],
... holidays=['2011-07-01', '2011-07-04', '2011-07-17'])
array([False, False, True])

isclose(a, b, rtol=1e-05, atol=1e-08, equal_nan=False)

Returns a boolean array where two arrays are element-wise equal within a
tolerance.

The tolerance values are positive, typically very small numbers. The
relative difference (`rtol` * abs(`b`)) and the absolute difference
`atol` are added together to compare against the absolute difference
between `a` and `b`.

.. warning:: The default `atol` is not appropriate for comparing numbers

that are much smaller than one (see Notes).

Parameters
----------
a, b : array_like
Input arrays to compare.
rtol : float
The relative tolerance parameter (see Notes).
atol : float
The absolute tolerance parameter (see Notes).
equal_nan : bool
Whether to compare NaN's as equal. If True, NaN's in `a` will be
considered equal to NaN's in `b` in the output array.

Returns
-------
y : array_like
Returns a boolean array of where `a` and `b` are equal within the
given tolerance. If both `a` and `b` are scalars, returns a single
boolean value.

See Also
--------
allclose
math.isclose

Notes
-----
.. versionadded:: 1.7.0

For finite values, isclose uses the following equation to test whether
two floating point values are equivalent.
 absolute(`a` - `b`) <= (`atol` + `rtol` * absolute(`b`))

Unlike the built-in `math.isclose`, the above equation is not symmetric

in `a` and `b` -- it assumes `b` is the reference value -- so that
`isclose(a, b)` might be different from `isclose(b, a)`. Furthermore,
the default value of atol is not zero, and is used to determine what
small values should be considered close to zero. The default value is
appropriate for expected values of order unity: if the expected values
are significantly smaller than one, it can result in false positives.
`atol` should be carefully selected for the use case at hand. A zero value
for `atol` will result in `False` if either `a` or `b` is zero.

`isclose` is not defined for non-numeric data types.

`bool` is considered a numeric data-type for this purpose.

Examples
--------
>>> np.isclose([1e10,1e-7], [1.00001e10,1e-8])
array([ True, False])
>>> np.isclose([1e10,1e-8], [1.00001e10,1e-9])
array([ True, True])
>>> np.isclose([1e10,1e-8], [1.0001e10,1e-9])
array([False, True])
>>> np.isclose([1.0, np.nan], [1.0, np.nan])
array([ True, False])
>>> np.isclose([1.0, np.nan], [1.0, np.nan], equal_nan=True)
array([ True, True])
>>> np.isclose([1e-8, 1e-7], [0.0, 0.0])
array([ True, False])
>>> np.isclose([1e-100, 1e-7], [0.0, 0.0], atol=0.0)
array([False, False])
>>> np.isclose([1e-10, 1e-10], [1e-20, 0.0])
array([ True, True])
>>> np.isclose([1e-10, 1e-10], [1e-20, 0.999999e-10], atol=0.0)
array([False, True])

iscomplex(x)
Returns a bool array, where True if input element is complex.

What is tested is whether the input has a non-zero imaginary part, not if
the input type is complex.

Parameters
----------
x : array_like
Input array.

Returns
-------
out : ndarray of bools
Output array.

See Also
--------
isreal
iscomplexobj : Return True if x is a complex type or an array of complex
numbers.
 Examples
--------
>>> np.iscomplex([1+1j, 1+0j, 4.5, 3, 2, 2j])
array([ True, False, False, False, False, True])

iscomplexobj(x)
Check for a complex type or an array of complex numbers.

The type of the input is checked, not the value. Even if the input
has an imaginary part equal to zero, `iscomplexobj` evaluates to True.

Parameters
----------
x : any
The input can be of any type and shape.

Returns
-------
iscomplexobj : bool
The return value, True if `x` is of a complex type or has at least
one complex element.

See Also
--------
isrealobj, iscomplex

Examples
--------
>>> np.iscomplexobj(1)
False
>>> np.iscomplexobj(1+0j)
True
>>> np.iscomplexobj([3, 1+0j, True])
True

isfortran(a)
Check if the array is Fortran contiguous but *not* C contiguous.

This function is obsolete and, because of changes due to relaxed stride

checking, its return value for the same array may differ for versions
of NumPy >= 1.10.0 and previous versions. If you only want to check if an
array is Fortran contiguous use ``a.flags.f_contiguous`` instead.

Parameters
----------
a : ndarray
Input array.

Returns
-------
isfortran : bool
Returns True if the array is Fortran contiguous but *not* C contiguous.

Examples
--------

np.array allows to specify whether the array is written in C-contiguous

order (last index varies the fastest), or FORTRAN-contiguous order in
 memory (first index varies the fastest).

>>> a = np.array([[1, 2, 3], [4, 5, 6]], order='C')

>>> a
array([[1, 2, 3],
[4, 5, 6]])
>>> np.isfortran(a)
False

>>> b = np.array([[1, 2, 3], [4, 5, 6]], order='F')

>>> b
array([[1, 2, 3],
[4, 5, 6]])
>>> np.isfortran(b)
True

The transpose of a C-ordered array is a FORTRAN-ordered array.

>>> a = np.array([[1, 2, 3], [4, 5, 6]], order='C')

>>> a
array([[1, 2, 3],
[4, 5, 6]])
>>> np.isfortran(a)
False
>>> b = a.T
>>> b
array([[1, 4],
[2, 5],
[3, 6]])
>>> np.isfortran(b)
True

C-ordered arrays evaluate as False even if they are also FORTRAN-ordered.

>>> np.isfortran(np.array([1, 2], order='F'))

False

isin(element, test_elements, assume_unique=False, invert=False, *, kind=None)

Calculates ``element in test_elements``, broadcasting over `element` only.
Returns a boolean array of the same shape as `element` that is True
where an element of `element` is in `test_elements` and False otherwise.

Parameters
----------
element : array_like
Input array.
test_elements : array_like
The values against which to test each value of `element`.
This argument is flattened if it is an array or array_like.
See notes for behavior with non-array-like parameters.
assume_unique : bool, optional
If True, the input arrays are both assumed to be unique, which
can speed up the calculation. Default is False.
invert : bool, optional
If True, the values in the returned array are inverted, as if
calculating `element not in test_elements`. Default is False.
``np.isin(a, b, invert=True)`` is equivalent to (but faster
than) ``np.invert(np.isin(a, b))``.
kind : {None, 'sort', 'table'}, optional
The algorithm to use. This will not affect the final result,
but will affect the speed and memory use. The default, None,
will select automatically based on memory considerations.

* If 'sort', will use a mergesort-based approach. This will have

a memory usage of roughly 6 times the sum of the sizes of
`ar1` and `ar2`, not accounting for size of dtypes.
* If 'table', will use a lookup table approach similar
to a counting sort. This is only available for boolean and
integer arrays. This will have a memory usage of the
size of `ar1` plus the max-min value of `ar2`. `assume_unique`
has no effect when the 'table' option is used.
* If None, will automatically choose 'table' if
the required memory allocation is less than or equal to
6 times the sum of the sizes of `ar1` and `ar2`,
otherwise will use 'sort'. This is done to not use
a large amount of memory by default, even though
'table' may be faster in most cases. If 'table' is chosen,
`assume_unique` will have no effect.

Returns
-------
isin : ndarray, bool
Has the same shape as `element`. The values `element[isin]`
are in `test_elements`.

See Also
--------
in1d : Flattened version of this function.
numpy.lib.arraysetops : Module with a number of other functions for
performing set operations on arrays.

Notes
-----

`isin` is an element-wise function version of the python keyword `in`.

``isin(a, b)`` is roughly equivalent to
``np.array([item in b for item in a])`` if `a` and `b` are 1-D sequences.

`element` and `test_elements` are converted to arrays if they are not

already. If `test_elements` is a set (or other non-sequence collection)
it will be converted to an object array with one element, rather than an
array of the values contained in `test_elements`. This is a consequence
of the `array` constructor's way of handling non-sequence collections.
Converting the set to a list usually gives the desired behavior.

Using ``kind='table'`` tends to be faster than `kind='sort'` if the

following relationship is true:
``log10(len(ar2)) > (log10(max(ar2)-min(ar2)) - 2.27) / 0.927``,
but may use greater memory. The default value for `kind` will
be automatically selected based only on memory usage, so one may
manually set ``kind='table'`` if memory constraints can be relaxed.

.. versionadded:: 1.13.0

Examples
--------
 >>> element = 2*np.arange(4).reshape((2, 2))
>>> element
array([[0, 2],
[4, 6]])
>>> test_elements = [1, 2, 4, 8]
>>> mask = np.isin(element, test_elements)
>>> mask
array([[False, True],
[ True, False]])
>>> element[mask]
array([2, 4])

The indices of the matched values can be obtained with `nonzero`:

>>> np.nonzero(mask)
(array([0, 1]), array([1, 0]))

The test can also be inverted:

>>> mask = np.isin(element, test_elements, invert=True)

>>> mask
array([[ True, False],
[False, True]])
>>> element[mask]
array([0, 6])

Because of how `array` handles sets, the following does not

work as expected:

>>> test_set = {1, 2, 4, 8}

>>> np.isin(element, test_set)
array([[False, False],
[False, False]])

Casting the set to a list gives the expected result:

>>> np.isin(element, list(test_set))

array([[False, True],
[ True, False]])

isneginf(x, out=None)
Test element-wise for negative infinity, return result as bool array.

Parameters
----------
x : array_like
The input array.
out : array_like, optional
A location into which the result is stored. If provided, it must have a
shape that the input broadcasts to. If not provided or None, a
freshly-allocated boolean array is returned.

Returns
-------
out : ndarray
A boolean array with the same dimensions as the input.
If second argument is not supplied then a numpy boolean array is
returned with values True where the corresponding element of the
input is negative infinity and values False where the element of
 the input is not negative infinity.

If a second argument is supplied the result is stored there. If the

type of that array is a numeric type the result is represented as
zeros and ones, if the type is boolean then as False and True. The
return value `out` is then a reference to that array.

See Also
--------
isinf, isposinf, isnan, isfinite

Notes
-----
NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic
(IEEE 754).

Errors result if the second argument is also supplied when x is a scalar

input, if first and second arguments have different shapes, or if the
first argument has complex values.

Examples
--------
>>> np.isneginf(np.NINF)
True
>>> np.isneginf(np.inf)
False
>>> np.isneginf(np.PINF)
False
>>> np.isneginf([-np.inf, 0., np.inf])
array([ True, False, False])

>>> x = np.array([-np.inf, 0., np.inf])

>>> y = np.array([2, 2, 2])
>>> np.isneginf(x, y)
array([1, 0, 0])
>>> y
array([1, 0, 0])

isposinf(x, out=None)
Test element-wise for positive infinity, return result as bool array.

Parameters
----------
x : array_like
The input array.
out : array_like, optional
A location into which the result is stored. If provided, it must have a
shape that the input broadcasts to. If not provided or None, a
freshly-allocated boolean array is returned.

Returns
-------
out : ndarray
A boolean array with the same dimensions as the input.
If second argument is not supplied then a boolean array is returned
with values True where the corresponding element of the input is
positive infinity and values False where the element of the input is
not positive infinity.
 If a second argument is supplied the result is stored there. If the
type of that array is a numeric type the result is represented as zeros
and ones, if the type is boolean then as False and True.
The return value `out` is then a reference to that array.

See Also
--------
isinf, isneginf, isfinite, isnan

Notes
-----
NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic
(IEEE 754).

Errors result if the second argument is also supplied when x is a scalar

input, if first and second arguments have different shapes, or if the
first argument has complex values

Examples
--------
>>> np.isposinf(np.PINF)
True
>>> np.isposinf(np.inf)
True
>>> np.isposinf(np.NINF)
False
>>> np.isposinf([-np.inf, 0., np.inf])
array([False, False, True])

>>> x = np.array([-np.inf, 0., np.inf])

>>> y = np.array([2, 2, 2])
>>> np.isposinf(x, y)
array([0, 0, 1])
>>> y
array([0, 0, 1])

isreal(x)
Returns a bool array, where True if input element is real.

If element has complex type with zero complex part, the return value
for that element is True.

Parameters
----------
x : array_like
Input array.

Returns
-------
out : ndarray, bool
Boolean array of same shape as `x`.

Notes
-----
`isreal` may behave unexpectedly for string or object arrays (see examples)

See Also
--------
iscomplex
 isrealobj : Return True if x is not a complex type.

Examples
--------
>>> a = np.array([1+1j, 1+0j, 4.5, 3, 2, 2j], dtype=complex)
>>> np.isreal(a)
array([False, True, True, True, True, False])

The function does not work on string arrays.

>>> a = np.array([2j, "a"], dtype="U")

>>> np.isreal(a) # Warns about non-elementwise comparison
False

Returns True for all elements in input array of ``dtype=object`` even if

any of the elements is complex.

>>> a = np.array([1, "2", 3+4j], dtype=object)

>>> np.isreal(a)
array([ True, True, True])

isreal should not be used with object arrays

>>> a = np.array([1+2j, 2+1j], dtype=object)

>>> np.isreal(a)
array([ True, True])

isrealobj(x)
Return True if x is a not complex type or an array of complex numbers.

The type of the input is checked, not the value. So even if the input
has an imaginary part equal to zero, `isrealobj` evaluates to False
if the data type is complex.

Parameters
----------
x : any
The input can be of any type and shape.

Returns
-------
y : bool
The return value, False if `x` is of a complex type.

See Also
--------
iscomplexobj, isreal

Notes
-----
The function is only meant for arrays with numerical values but it
accepts all other objects. Since it assumes array input, the return
value of other objects may be True.

>>> np.isrealobj('A string')

True
>>> np.isrealobj(False)
True
>>> np.isrealobj(None)
 True

Examples
--------
>>> np.isrealobj(1)
True
>>> np.isrealobj(1+0j)
False
>>> np.isrealobj([3, 1+0j, True])
False

isscalar(element)
Returns True if the type of `element` is a scalar type.

Parameters
----------
element : any
Input argument, can be of any type and shape.

Returns
-------
val : bool
True if `element` is a scalar type, False if it is not.

See Also
--------
ndim : Get the number of dimensions of an array

Notes
-----
If you need a stricter way to identify a *numerical* scalar, use
``isinstance(x, numbers.Number)``, as that returns ``False`` for most
non-numerical elements such as strings.

In most cases ``np.ndim(x) == 0`` should be used instead of this function,

as that will also return true for 0d arrays. This is how numpy overloads
functions in the style of the ``dx`` arguments to `gradient` and the
``bins``
argument to `histogram`. Some key differences:

+--------------------------------------+---------------+-------------------
+
| x |``isscalar(x)``|``np.ndim(x) ==
0``|

+======================================+===============+===================+
| PEP 3141 numeric objects (including | ``True`` | ``True``
|
| builtins) | |
|
+--------------------------------------+---------------+-------------------
+
| builtin string and buffer objects | ``True`` | ``True``
|
+--------------------------------------+---------------+-------------------
+
| other builtin objects, like | ``False`` | ``True``
|
| `pathlib.Path`, `Exception`, | |
|
| the result of `re.compile` | |
|
+--------------------------------------+---------------+-------------------
+
| third-party objects like | ``False`` | ``True``
|
| `matplotlib.figure.Figure` | |
|
+--------------------------------------+---------------+-------------------
+
| zero-dimensional numpy arrays | ``False`` | ``True``
|
+--------------------------------------+---------------+-------------------
+
| other numpy arrays | ``False`` | ``False``
|
+--------------------------------------+---------------+-------------------
+
| `list`, `tuple`, and other sequence | ``False`` | ``False``
|
| objects | |
|
+--------------------------------------+---------------+-------------------
+

Examples
--------
>>> np.isscalar(3.1)
True
>>> np.isscalar(np.array(3.1))
False
>>> np.isscalar([3.1])
False
>>> np.isscalar(False)
True
>>> np.isscalar('numpy')
True

NumPy supports PEP 3141 numbers:

>>> from fractions import Fraction

>>> np.isscalar(Fraction(5, 17))
True
>>> from numbers import Number
>>> np.isscalar(Number())
True

issctype(rep)
Determines whether the given object represents a scalar data-type.

Parameters
----------
rep : any
If `rep` is an instance of a scalar dtype, True is returned. If not,
False is returned.

Returns
-------
 out : bool
Boolean result of check whether `rep` is a scalar dtype.

See Also
--------
issubsctype, issubdtype, obj2sctype, sctype2char

Examples
--------
>>> np.issctype(np.int32)
True
>>> np.issctype(list)
False
>>> np.issctype(1.1)
False

Strings are also a scalar type:

>>> np.issctype(np.dtype('str'))
True

issubclass_(arg1, arg2)
Determine if a class is a subclass of a second class.

`issubclass_` is equivalent to the Python built-in ``issubclass``,

except that it returns False instead of raising a TypeError if one
of the arguments is not a class.

Parameters
----------
arg1 : class
Input class. True is returned if `arg1` is a subclass of `arg2`.
arg2 : class or tuple of classes.
Input class. If a tuple of classes, True is returned if `arg1` is a
subclass of any of the tuple elements.

Returns
-------
out : bool
Whether `arg1` is a subclass of `arg2` or not.

See Also
--------
issubsctype, issubdtype, issctype

Examples
--------
>>> np.issubclass_(np.int32, int)
False
>>> np.issubclass_(np.int32, float)
False
>>> np.issubclass_(np.float64, float)
True

issubdtype(arg1, arg2)
Returns True if first argument is a typecode lower/equal in type hierarchy.

This is like the builtin :func:`issubclass`, but for `dtype`\ s.

 Parameters
----------
arg1, arg2 : dtype_like
`dtype` or object coercible to one

Returns
-------
out : bool

See Also
--------
:ref:`arrays.scalars` : Overview of the numpy type hierarchy.
issubsctype, issubclass_

Examples
--------
`issubdtype` can be used to check the type of arrays:

>>> ints = np.array([1, 2, 3], dtype=np.int32)

>>> np.issubdtype(ints.dtype, np.integer)
True
>>> np.issubdtype(ints.dtype, np.floating)
False

>>> floats = np.array([1, 2, 3], dtype=np.float32)

>>> np.issubdtype(floats.dtype, np.integer)
False
>>> np.issubdtype(floats.dtype, np.floating)
True

Similar types of different sizes are not subdtypes of each other:

>>> np.issubdtype(np.float64, np.float32)

False
>>> np.issubdtype(np.float32, np.float64)
False

but both are subtypes of `floating`:

>>> np.issubdtype(np.float64, np.floating)

True
>>> np.issubdtype(np.float32, np.floating)
True

For convenience, dtype-like objects are allowed too:

>>> np.issubdtype('S1', np.string_)

True
>>> np.issubdtype('i4', np.signedinteger)
True

issubsctype(arg1, arg2)
Determine if the first argument is a subclass of the second argument.

Parameters
----------
arg1, arg2 : dtype or dtype specifier
Data-types.
 Returns
-------
out : bool
The result.

See Also
--------
issctype, issubdtype, obj2sctype

Examples
--------
>>> np.issubsctype('S8', str)
False
>>> np.issubsctype(np.array([1]), int)
True
>>> np.issubsctype(np.array([1]), float)
False

iterable(y)
Check whether or not an object can be iterated over.

Parameters
----------
y : object
Input object.

Returns
-------
b : bool
Return ``True`` if the object has an iterator method or is a
sequence and ``False`` otherwise.

Examples
--------
>>> np.iterable([1, 2, 3])
True
>>> np.iterable(2)
False

Notes
-----
In most cases, the results of ``np.iterable(obj)`` are consistent with
``isinstance(obj, collections.abc.Iterable)``. One notable exception is
the treatment of 0-dimensional arrays::

>>> from collections.abc import Iterable

>>> a = np.array(1.0) # 0-dimensional numpy array
>>> isinstance(a, Iterable)
True
>>> np.iterable(a)
False

ix_(*args)
Construct an open mesh from multiple sequences.

This function takes N 1-D sequences and returns N outputs with N

dimensions each, such that the shape is 1 in all but one dimension
and the dimension with the non-unit shape value cycles through all
 N dimensions.

Using `ix_` one can quickly construct index arrays that will index
the cross product. ``a[np.ix_([1,3],[2,5])]`` returns the array
``[[a[1,2] a[1,5]], [a[3,2] a[3,5]]]``.

Parameters
----------
args : 1-D sequences
Each sequence should be of integer or boolean type.
Boolean sequences will be interpreted as boolean masks for the
corresponding dimension (equivalent to passing in
``np.nonzero(boolean_sequence)``).

Returns
-------
out : tuple of ndarrays
N arrays with N dimensions each, with N the number of input
sequences. Together these arrays form an open mesh.

See Also
--------
ogrid, mgrid, meshgrid

Examples
--------
>>> a = np.arange(10).reshape(2, 5)
>>> a
array([[0, 1, 2, 3, 4],
[5, 6, 7, 8, 9]])
>>> ixgrid = np.ix_([0, 1], [2, 4])
>>> ixgrid
(array([[0],
[1]]), array([[2, 4]]))
>>> ixgrid[0].shape, ixgrid[1].shape
((2, 1), (1, 2))
>>> a[ixgrid]
array([[2, 4],
[7, 9]])

>>> ixgrid = np.ix_([True, True], [2, 4])

>>> a[ixgrid]
array([[2, 4],
[7, 9]])
>>> ixgrid = np.ix_([True, True], [False, False, True, False, True])
>>> a[ixgrid]
array([[2, 4],
[7, 9]])

kaiser(M, beta)
Return the Kaiser window.

The Kaiser window is a taper formed by using a Bessel function.

Parameters
----------
M : int
Number of points in the output window. If zero or less, an
empty array is returned.
beta : float
Shape parameter for window.

Returns
-------
out : array
The window, with the maximum value normalized to one (the value
one appears only if the number of samples is odd).

See Also
--------
bartlett, blackman, hamming, hanning

Notes
-----
The Kaiser window is defined as

.. math:: w(n) = I_0\left( \beta \sqrt{1-\frac{4n^2}{(M-1)^2}}

\right)/I_0(\beta)

with

.. math:: \quad -\frac{M-1}{2} \leq n \leq \frac{M-1}{2},

where :math:`I_0` is the modified zeroth-order Bessel function.

The Kaiser was named for Jim Kaiser, who discovered a simple
approximation to the DPSS window based on Bessel functions. The Kaiser
window is a very good approximation to the Digital Prolate Spheroidal
Sequence, or Slepian window, which is the transform which maximizes the
energy in the main lobe of the window relative to total energy.

The Kaiser can approximate many other windows by varying the beta
parameter.

==== =======================
beta Window shape
==== =======================
0 Rectangular
5 Similar to a Hamming
6 Similar to a Hanning
8.6 Similar to a Blackman
==== =======================

A beta value of 14 is probably a good starting point. Note that as beta

gets large, the window narrows, and so the number of samples needs to be
large enough to sample the increasingly narrow spike, otherwise NaNs will
get returned.

Most references to the Kaiser window come from the signal processing
literature, where it is used as one of many windowing functions for
smoothing values. It is also known as an apodization (which means
"removing the foot", i.e. smoothing discontinuities at the beginning
and end of the sampled signal) or tapering function.

References
----------
.. [1] J. F. Kaiser, "Digital Filters" - Ch 7 in "Systems analysis by
digital computer", Editors: F.F. Kuo and J.F. Kaiser, p 218-285.
 John Wiley and Sons, New York, (1966).
.. [2] E.R. Kanasewich, "Time Sequence Analysis in Geophysics", The
University of Alberta Press, 1975, pp. 177-178.
.. [3] Wikipedia, "Window function",
https://en.wikipedia.org/wiki/Window_function

Examples
--------
>>> import matplotlib.pyplot as plt
>>> np.kaiser(12, 14)
array([7.72686684e-06, 3.46009194e-03, 4.65200189e-02, # may vary
2.29737120e-01, 5.99885316e-01, 9.45674898e-01,
9.45674898e-01, 5.99885316e-01, 2.29737120e-01,
4.65200189e-02, 3.46009194e-03, 7.72686684e-06])

Plot the window and the frequency response:

>>> from numpy.fft import fft, fftshift

>>> window = np.kaiser(51, 14)
>>> plt.plot(window)
[<matplotlib.lines.Line2D object at 0x...>]
>>> plt.title("Kaiser window")
Text(0.5, 1.0, 'Kaiser window')
>>> plt.ylabel("Amplitude")
Text(0, 0.5, 'Amplitude')
>>> plt.xlabel("Sample")
Text(0.5, 0, 'Sample')
>>> plt.show()

>>> plt.figure()
<Figure size 640x480 with 0 Axes>
>>> A = fft(window, 2048) / 25.5
>>> mag = np.abs(fftshift(A))
>>> freq = np.linspace(-0.5, 0.5, len(A))
>>> response = 20 * np.log10(mag)
>>> response = np.clip(response, -100, 100)
>>> plt.plot(freq, response)
[<matplotlib.lines.Line2D object at 0x...>]
>>> plt.title("Frequency response of Kaiser window")
Text(0.5, 1.0, 'Frequency response of Kaiser window')
>>> plt.ylabel("Magnitude [dB]")
Text(0, 0.5, 'Magnitude [dB]')
>>> plt.xlabel("Normalized frequency [cycles per sample]")
Text(0.5, 0, 'Normalized frequency [cycles per sample]')
>>> plt.axis('tight')
(-0.5, 0.5, -100.0, ...) # may vary
>>> plt.show()

kron(a, b)
Kronecker product of two arrays.

Computes the Kronecker product, a composite array made of blocks of the

second array scaled by the first.

Parameters
----------
a, b : array_like
 Returns
-------
out : ndarray

See Also
--------
outer : The outer product

Notes
-----
The function assumes that the number of dimensions of `a` and `b`
are the same, if necessary prepending the smallest with ones.
If ``a.shape = (r0,r1,..,rN)`` and ``b.shape = (s0,s1,...,sN)``,
the Kronecker product has shape ``(r0*s0, r1*s1, ..., rN*SN)``.
The elements are products of elements from `a` and `b`, organized
explicitly by::

kron(a,b)[k0,k1,...,kN] = a[i0,i1,...,iN] * b[j0,j1,...,jN]

where::

kt = it * st + jt, t = 0,...,N

In the common 2-D case (N=1), the block structure can be visualized::

[[ a[0,0]*b, a[0,1]*b, ... , a[0,-1]*b ],

[ ... ... ],
[ a[-1,0]*b, a[-1,1]*b, ... , a[-1,-1]*b ]]

Examples
--------
>>> np.kron([1,10,100], [5,6,7])
array([ 5, 6, 7, ..., 500, 600, 700])
>>> np.kron([5,6,7], [1,10,100])
array([ 5, 50, 500, ..., 7, 70, 700])

>>> np.kron(np.eye(2), np.ones((2,2)))

array([[1., 1., 0., 0.],
[1., 1., 0., 0.],
[0., 0., 1., 1.],
[0., 0., 1., 1.]])

>>> a = np.arange(100).reshape((2,5,2,5))
>>> b = np.arange(24).reshape((2,3,4))
>>> c = np.kron(a,b)
>>> c.shape
(2, 10, 6, 20)
>>> I = (1,3,0,2)
>>> J = (0,2,1)
>>> J1 = (0,) + J # extend to ndim=4
>>> S1 = (1,) + b.shape
>>> K = tuple(np.array(I) * np.array(S1) + np.array(J1))
>>> c[K] == a[I]*b[J]
True

lexsort(...)
lexsort(keys, axis=-1)
Perform an indirect stable sort using a sequence of keys.

Given multiple sorting keys, which can be interpreted as columns in a

spreadsheet, lexsort returns an array of integer indices that describes
the sort order by multiple columns. The last key in the sequence is used
for the primary sort order, the second-to-last key for the secondary sort
order, and so on. The keys argument must be a sequence of objects that
can be converted to arrays of the same shape. If a 2D array is provided
for the keys argument, its rows are interpreted as the sorting keys and
sorting is according to the last row, second last row etc.

Parameters
----------
keys : (k, N) array or tuple containing k (N,)-shaped sequences
The `k` different "columns" to be sorted. The last column (or row if
`keys` is a 2D array) is the primary sort key.
axis : int, optional
Axis to be indirectly sorted. By default, sort over the last axis.

Returns
-------
indices : (N,) ndarray of ints
Array of indices that sort the keys along the specified axis.

See Also
--------
argsort : Indirect sort.
ndarray.sort : In-place sort.
sort : Return a sorted copy of an array.

Examples
--------
Sort names: first by surname, then by name.

>>> surnames = ('Hertz', 'Galilei', 'Hertz')

>>> first_names = ('Heinrich', 'Galileo', 'Gustav')
>>> ind = np.lexsort((first_names, surnames))
>>> ind
array([1, 2, 0])

>>> [surnames[i] + ", " + first_names[i] for i in ind]

['Galilei, Galileo', 'Hertz, Gustav', 'Hertz, Heinrich']

Sort two columns of numbers:

>>> a = [1,5,1,4,3,4,4] # First column

>>> b = [9,4,0,4,0,2,1] # Second column
>>> ind = np.lexsort((b,a)) # Sort by a, then by b
>>> ind
array([2, 0, 4, 6, 5, 3, 1])

>>> [(a[i],b[i]) for i in ind]

[(1, 0), (1, 9), (3, 0), (4, 1), (4, 2), (4, 4), (5, 4)]

Note that sorting is first according to the elements of ``a``.

Secondary sorting is according to the elements of ``b``.

A normal ``argsort`` would have yielded:

 >>> [(a[i],b[i]) for i in np.argsort(a)]
[(1, 9), (1, 0), (3, 0), (4, 4), (4, 2), (4, 1), (5, 4)]

Structured arrays are sorted lexically by ``argsort``:

>>> x = np.array([(1,9), (5,4), (1,0), (4,4), (3,0), (4,2), (4,1)],

... dtype=np.dtype([('x', int), ('y', int)]))

>>> np.argsort(x) # or np.argsort(x, order=('x', 'y'))

array([2, 0, 4, 6, 5, 3, 1])

linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None, axis=0)

Return evenly spaced numbers over a specified interval.

Returns `num` evenly spaced samples, calculated over the

interval [`start`, `stop`].

The endpoint of the interval can optionally be excluded.

.. versionchanged:: 1.16.0
Non-scalar `start` and `stop` are now supported.

.. versionchanged:: 1.20.0
Values are rounded towards ``-inf`` instead of ``0`` when an
integer ``dtype`` is specified. The old behavior can
still be obtained with ``np.linspace(start, stop, num).astype(int)``

Parameters
----------
start : array_like
The starting value of the sequence.
stop : array_like
The end value of the sequence, unless `endpoint` is set to False.
In that case, the sequence consists of all but the last of ``num + 1``
evenly spaced samples, so that `stop` is excluded. Note that the step
size changes when `endpoint` is False.
num : int, optional
Number of samples to generate. Default is 50. Must be non-negative.
endpoint : bool, optional
If True, `stop` is the last sample. Otherwise, it is not included.
Default is True.
retstep : bool, optional
If True, return (`samples`, `step`), where `step` is the spacing
between samples.
dtype : dtype, optional
The type of the output array. If `dtype` is not given, the data type
is inferred from `start` and `stop`. The inferred dtype will never be
an integer; `float` is chosen even if the arguments would produce an
array of integers.

.. versionadded:: 1.9.0

axis : int, optional

The axis in the result to store the samples. Relevant only if start
or stop are array-like. By default (0), the samples will be along a
new axis inserted at the beginning. Use -1 to get an axis at the end.

.. versionadded:: 1.16.0
 Returns
-------
samples : ndarray
There are `num` equally spaced samples in the closed interval
``[start, stop]`` or the half-open interval ``[start, stop)``
(depending on whether `endpoint` is True or False).
step : float, optional
Only returned if `retstep` is True

Size of spacing between samples.

See Also
--------
arange : Similar to `linspace`, but uses a step size (instead of the
number of samples).
geomspace : Similar to `linspace`, but with numbers spaced evenly on a log
scale (a geometric progression).
logspace : Similar to `geomspace`, but with the end points specified as
logarithms.
:ref:`how-to-partition`

Examples
--------
>>> np.linspace(2.0, 3.0, num=5)
array([2. , 2.25, 2.5 , 2.75, 3. ])
>>> np.linspace(2.0, 3.0, num=5, endpoint=False)
array([2. , 2.2, 2.4, 2.6, 2.8])
>>> np.linspace(2.0, 3.0, num=5, retstep=True)
(array([2. , 2.25, 2.5 , 2.75, 3. ]), 0.25)

Graphical illustration:

>>> import matplotlib.pyplot as plt

>>> N = 8
>>> y = np.zeros(N)
>>> x1 = np.linspace(0, 10, N, endpoint=True)
>>> x2 = np.linspace(0, 10, N, endpoint=False)
>>> plt.plot(x1, y, 'o')
[<matplotlib.lines.Line2D object at 0x...>]
>>> plt.plot(x2, y + 0.5, 'o')
[<matplotlib.lines.Line2D object at 0x...>]
>>> plt.ylim([-0.5, 1])
(-0.5, 1)
>>> plt.show()

load(file, mmap_mode=None, allow_pickle=False, fix_imports=True,

encoding='ASCII', *, max_header_size=10000)
Load arrays or pickled objects from ``.npy``, ``.npz`` or pickled files.

.. warning:: Loading files that contain object arrays uses the ``pickle``
module, which is not secure against erroneous or maliciously
constructed data. Consider passing ``allow_pickle=False`` to
load data that is known not to contain object arrays for the
safer handling of untrusted sources.

Parameters
----------
file : file-like object, string, or pathlib.Path
 The file to read. File-like objects must support the
``seek()`` and ``read()`` methods and must always
be opened in binary mode. Pickled files require that the
file-like object support the ``readline()`` method as well.
mmap_mode : {None, 'r+', 'r', 'w+', 'c'}, optional
If not None, then memory-map the file, using the given mode (see
`numpy.memmap` for a detailed description of the modes). A
memory-mapped array is kept on disk. However, it can be accessed
and sliced like any ndarray. Memory mapping is especially useful
for accessing small fragments of large files without reading the
entire file into memory.
allow_pickle : bool, optional
Allow loading pickled object arrays stored in npy files. Reasons for
disallowing pickles include security, as loading pickled data can
execute arbitrary code. If pickles are disallowed, loading object
arrays will fail. Default: False

.. versionchanged:: 1.16.3
Made default False in response to CVE-2019-6446.

fix_imports : bool, optional

Only useful when loading Python 2 generated pickled files on Python 3,
which includes npy/npz files containing object arrays. If `fix_imports`
is True, pickle will try to map the old Python 2 names to the new names
used in Python 3.
encoding : str, optional
What encoding to use when reading Python 2 strings. Only useful when
loading Python 2 generated pickled files in Python 3, which includes
npy/npz files containing object arrays. Values other than 'latin1',
'ASCII', and 'bytes' are not allowed, as they can corrupt numerical
data. Default: 'ASCII'
max_header_size : int, optional
Maximum allowed size of the header. Large headers may not be safe
to load securely and thus require explicitly passing a larger value.
See :py:func:`ast.literal_eval()` for details.
This option is ignored when `allow_pickle` is passed. In that case
the file is by definition trusted and the limit is unnecessary.

Returns
-------
result : array, tuple, dict, etc.
Data stored in the file. For ``.npz`` files, the returned instance
of NpzFile class must be closed to avoid leaking file descriptors.

Raises
------
OSError
If the input file does not exist or cannot be read.
UnpicklingError
If ``allow_pickle=True``, but the file cannot be loaded as a pickle.
ValueError
The file contains an object array, but ``allow_pickle=False`` given.
EOFError
When calling ``np.load`` multiple times on the same file handle,
if all data has already been read

See Also
--------
save, savez, savez_compressed, loadtxt
 memmap : Create a memory-map to an array stored in a file on disk.
lib.format.open_memmap : Create or load a memory-mapped ``.npy`` file.

Notes
-----
- If the file contains pickle data, then whatever object is stored
in the pickle is returned.
- If the file is a ``.npy`` file, then a single array is returned.
- If the file is a ``.npz`` file, then a dictionary-like object is
returned, containing ``{filename: array}`` key-value pairs, one for
each file in the archive.
- If the file is a ``.npz`` file, the returned value supports the
context manager protocol in a similar fashion to the open function::

with load('foo.npz') as data:

a = data['a']

The underlying file descriptor is closed when exiting the 'with'

block.

Examples
--------
Store data to disk, and load it again:

>>> np.save('/tmp/123', np.array([[1, 2, 3], [4, 5, 6]]))

>>> np.load('/tmp/123.npy')
array([[1, 2, 3],
[4, 5, 6]])

Store compressed data to disk, and load it again:

>>> a=np.array([[1, 2, 3], [4, 5, 6]])

>>> b=np.array([1, 2])
>>> np.savez('/tmp/123.npz', a=a, b=b)
>>> data = np.load('/tmp/123.npz')
>>> data['a']
array([[1, 2, 3],
[4, 5, 6]])
>>> data['b']
array([1, 2])
>>> data.close()

Mem-map the stored array, and then access the second row
directly from disk:

>>> X = np.load('/tmp/123.npy', mmap_mode='r')

>>> X[1, :]
memmap([4, 5, 6])

loadtxt(fname, dtype=<class 'float'>, comments='#', delimiter=None,

converters=None, skiprows=0, usecols=None, unpack=False, ndmin=0, encoding='bytes',
max_rows=None, *, quotechar=None, like=None)
Load data from a text file.

Parameters
----------
fname : file, str, pathlib.Path, list of str, generator
File, filename, list, or generator to read. If the filename
extension is ``.gz`` or ``.bz2``, the file is first decompressed. Note
 that generators must return bytes or strings. The strings
in a list or produced by a generator are treated as lines.
dtype : data-type, optional
Data-type of the resulting array; default: float. If this is a
structured data-type, the resulting array will be 1-dimensional, and
each row will be interpreted as an element of the array. In this
case, the number of columns used must match the number of fields in
the data-type.
comments : str or sequence of str or None, optional
The characters or list of characters used to indicate the start of a
comment. None implies no comments. For backwards compatibility, byte
strings will be decoded as 'latin1'. The default is '#'.
delimiter : str, optional
The character used to separate the values. For backwards compatibility,
byte strings will be decoded as 'latin1'. The default is whitespace.

.. versionchanged:: 1.23.0
Only single character delimiters are supported. Newline characters
cannot be used as the delimiter.

converters : dict or callable, optional

Converter functions to customize value parsing. If `converters` is
callable, the function is applied to all columns, else it must be a
dict that maps column number to a parser function.
See examples for further details.
Default: None.

.. versionchanged:: 1.23.0
The ability to pass a single callable to be applied to all columns
was added.

skiprows : int, optional

Skip the first `skiprows` lines, including comments; default: 0.
usecols : int or sequence, optional
Which columns to read, with 0 being the first. For example,
``usecols = (1,4,5)`` will extract the 2nd, 5th and 6th columns.
The default, None, results in all columns being read.

.. versionchanged:: 1.11.0
When a single column has to be read it is possible to use
an integer instead of a tuple. E.g ``usecols = 3`` reads the
fourth column the same way as ``usecols = (3,)`` would.
unpack : bool, optional
If True, the returned array is transposed, so that arguments may be
unpacked using ``x, y, z = loadtxt(...)``. When used with a
structured data-type, arrays are returned for each field.
Default is False.
ndmin : int, optional
The returned array will have at least `ndmin` dimensions.
Otherwise mono-dimensional axes will be squeezed.
Legal values: 0 (default), 1 or 2.

.. versionadded:: 1.6.0
encoding : str, optional
Encoding used to decode the inputfile. Does not apply to input streams.
The special value 'bytes' enables backward compatibility workarounds
that ensures you receive byte arrays as results if possible and passes
'latin1' encoded strings to converters. Override this value to receive
unicode arrays and pass strings as input to converters. If set to None
 the system default is used. The default value is 'bytes'.

.. versionadded:: 1.14.0
max_rows : int, optional
Read `max_rows` rows of content after `skiprows` lines. The default is
to read all the rows. Note that empty rows containing no data such as
empty lines and comment lines are not counted towards `max_rows`,
while such lines are counted in `skiprows`.

.. versionadded:: 1.16.0

.. versionchanged:: 1.23.0
Lines containing no data, including comment lines (e.g., lines
starting with '#' or as specified via `comments`) are not counted
towards `max_rows`.
quotechar : unicode character or None, optional
The character used to denote the start and end of a quoted item.
Occurrences of the delimiter or comment characters are ignored within
a quoted item. The default value is ``quotechar=None``, which means
quoting support is disabled.

If two consecutive instances of `quotechar` are found within a quoted

field, the first is treated as an escape character. See examples.

.. versionadded:: 1.23.0
like : array_like, optional
Reference object to allow the creation of arrays which are not
NumPy arrays. If an array-like passed in as ``like`` supports
the ``__array_function__`` protocol, the result will be defined
by it. In this case, it ensures the creation of an array object
compatible with that passed in via this argument.

.. versionadded:: 1.20.0

Returns
-------
out : ndarray
Data read from the text file.

See Also
--------
load, fromstring, fromregex
genfromtxt : Load data with missing values handled as specified.
scipy.io.loadmat : reads MATLAB data files

Notes
-----
This function aims to be a fast reader for simply formatted files. The
`genfromtxt` function provides more sophisticated handling of, e.g.,
lines with missing values.

Each row in the input text file must have the same number of values to be
able to read all values. If all rows do not have same number of values, a
subset of up to n columns (where n is the least number of values present
in all rows) can be read by specifying the columns via `usecols`.

.. versionadded:: 1.10.0

The strings produced by the Python float.hex method can be used as

input for floats.

Examples
--------
>>> from io import StringIO # StringIO behaves like a file object
>>> c = StringIO("0 1\n2 3")
>>> np.loadtxt(c)
array([[0., 1.],
[2., 3.]])

>>> d = StringIO("M 21 72\nF 35 58")

>>> np.loadtxt(d, dtype={'names': ('gender', 'age', 'weight'),
... 'formats': ('S1', 'i4', 'f4')})
array([(b'M', 21, 72.), (b'F', 35, 58.)],
dtype=[('gender', 'S1'), ('age', '<i4'), ('weight', '<f4')])

>>> c = StringIO("1,0,2\n3,0,4")
>>> x, y = np.loadtxt(c, delimiter=',', usecols=(0, 2), unpack=True)
>>> x
array([1., 3.])
>>> y
array([2., 4.])

The `converters` argument is used to specify functions to preprocess the

text prior to parsing. `converters` can be a dictionary that maps
preprocessing functions to each column:

>>> s = StringIO("1.618, 2.296\n3.141, 4.669\n")

>>> conv = {
... 0: lambda x: np.floor(float(x)), # conversion fn for column 0
... 1: lambda x: np.ceil(float(x)), # conversion fn for column 1
... }
>>> np.loadtxt(s, delimiter=",", converters=conv)
array([[1., 3.],
[3., 5.]])

`converters` can be a callable instead of a dictionary, in which case it

is applied to all columns:

>>> s = StringIO("0xDE 0xAD\n0xC0 0xDE")

>>> import functools
>>> conv = functools.partial(int, base=16)
>>> np.loadtxt(s, converters=conv)
array([[222., 173.],
[192., 222.]])

This example shows how `converters` can be used to convert a field

with a trailing minus sign into a negative number.

>>> s = StringIO('10.01 31.25-\n19.22 64.31\n17.57- 63.94')

>>> def conv(fld):
... return -float(fld[:-1]) if fld.endswith(b'-') else float(fld)
...
>>> np.loadtxt(s, converters=conv)
array([[ 10.01, -31.25],
[ 19.22, 64.31],
[-17.57, 63.94]])

Using a callable as the converter can be particularly useful for handling

values with different formatting, e.g. floats with underscores:

>>> s = StringIO("1 2.7 100_000")

>>> np.loadtxt(s, converters=float)
array([1.e+00, 2.7e+00, 1.e+05])

This idea can be extended to automatically handle values specified in

many different formats:

>>> def conv(val):

... try:
... return float(val)
... except ValueError:
... return float.fromhex(val)
>>> s = StringIO("1, 2.5, 3_000, 0b4, 0x1.4000000000000p+2")
>>> np.loadtxt(s, delimiter=",", converters=conv, encoding=None)
array([1.0e+00, 2.5e+00, 3.0e+03, 1.8e+02, 5.0e+00])

Note that with the default ``encoding="bytes"``, the inputs to the

converter function are latin-1 encoded byte strings. To deactivate the
implicit encoding prior to conversion, use ``encoding=None``

>>> s = StringIO('10.01 31.25-\n19.22 64.31\n17.57- 63.94')

>>> conv = lambda x: -float(x[:-1]) if x.endswith('-') else float(x)
>>> np.loadtxt(s, converters=conv, encoding=None)
array([[ 10.01, -31.25],
[ 19.22, 64.31],
[-17.57, 63.94]])

Support for quoted fields is enabled with the `quotechar` parameter.

Comment and delimiter characters are ignored when they appear within a
quoted item delineated by `quotechar`:

>>> s = StringIO('"alpha, #42", 10.0\n"beta, #64", 2.0\n')

>>> dtype = np.dtype([("label", "U12"), ("value", float)])
>>> np.loadtxt(s, dtype=dtype, delimiter=",", quotechar='"')
array([('alpha, #42', 10.), ('beta, #64', 2.)],
dtype=[('label', '<U12'), ('value', '<f8')])

Quoted fields can be separated by multiple whitespace characters:

>>> s = StringIO('"alpha, #42" 10.0\n"beta, #64" 2.0\n')

>>> dtype = np.dtype([("label", "U12"), ("value", float)])
>>> np.loadtxt(s, dtype=dtype, delimiter=None, quotechar='"')
array([('alpha, #42', 10.), ('beta, #64', 2.)],
dtype=[('label', '<U12'), ('value', '<f8')])

Two consecutive quote characters within a quoted field are treated as a

single escaped character:

>>> s = StringIO('"Hello, my name is ""Monty""!"')

>>> np.loadtxt(s, dtype="U", delimiter=",", quotechar='"')
array('Hello, my name is "Monty"!', dtype='<U26')

Read subset of columns when all rows do not contain equal number of values:

>>> d = StringIO("1 2\n2 4\n3 9 12\n4 16 20")

>>> np.loadtxt(d, usecols=(0, 1))
array([[ 1., 2.],
 [ 2., 4.],
[ 3., 9.],
[ 4., 16.]])

logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None, axis=0)

Return numbers spaced evenly on a log scale.

In linear space, the sequence starts at ``base ** start``

(`base` to the power of `start`) and ends with ``base ** stop``
(see `endpoint` below).

.. versionchanged:: 1.16.0
Non-scalar `start` and `stop` are now supported.

.. versionchanged:: 1.25.0
Non-scalar 'base` is now supported

Parameters
----------
start : array_like
``base ** start`` is the starting value of the sequence.
stop : array_like
``base ** stop`` is the final value of the sequence, unless `endpoint`
is False. In that case, ``num + 1`` values are spaced over the
interval in log-space, of which all but the last (a sequence of
length `num`) are returned.
num : integer, optional
Number of samples to generate. Default is 50.
endpoint : boolean, optional
If true, `stop` is the last sample. Otherwise, it is not included.
Default is True.
base : array_like, optional
The base of the log space. The step size between the elements in
``ln(samples) / ln(base)`` (or ``log_base(samples)``) is uniform.
Default is 10.0.
dtype : dtype
The type of the output array. If `dtype` is not given, the data type
is inferred from `start` and `stop`. The inferred type will never be
an integer; `float` is chosen even if the arguments would produce an
array of integers.
axis : int, optional
The axis in the result to store the samples. Relevant only if start,
stop, or base are array-like. By default (0), the samples will be
along a new axis inserted at the beginning. Use -1 to get an axis at
the end.

.. versionadded:: 1.16.0

Returns
-------
samples : ndarray
`num` samples, equally spaced on a log scale.

See Also
--------
arange : Similar to linspace, with the step size specified instead of the
number of samples. Note that, when used with a float endpoint, the
endpoint may or may not be included.
 linspace : Similar to logspace, but with the samples uniformly distributed
in linear space, instead of log space.
geomspace : Similar to logspace, but with endpoints specified directly.
:ref:`how-to-partition`

Notes
-----
If base is a scalar, logspace is equivalent to the code

>>> y = np.linspace(start, stop, num=num, endpoint=endpoint)

... # doctest: +SKIP
>>> power(base, y).astype(dtype)
... # doctest: +SKIP

Examples
--------
>>> np.logspace(2.0, 3.0, num=4)
array([ 100. , 215.443469 , 464.15888336, 1000. ])
>>> np.logspace(2.0, 3.0, num=4, endpoint=False)
array([100. , 177.827941 , 316.22776602, 562.34132519])
>>> np.logspace(2.0, 3.0, num=4, base=2.0)
array([4. , 5.0396842 , 6.34960421, 8. ])
>>> np.logspace(2.0, 3.0, num=4, base=[2.0, 3.0], axis=-1)
array([[ 4. , 5.0396842 , 6.34960421, 8. ],
[ 9. , 12.98024613, 18.72075441, 27. ]])

Graphical illustration:

>>> import matplotlib.pyplot as plt

>>> N = 10
>>> x1 = np.logspace(0.1, 1, N, endpoint=True)
>>> x2 = np.logspace(0.1, 1, N, endpoint=False)
>>> y = np.zeros(N)
>>> plt.plot(x1, y, 'o')
[<matplotlib.lines.Line2D object at 0x...>]
>>> plt.plot(x2, y + 0.5, 'o')
[<matplotlib.lines.Line2D object at 0x...>]
>>> plt.ylim([-0.5, 1])
(-0.5, 1)
>>> plt.show()

lookfor(what, module=None, import_modules=True, regenerate=False, output=None)

Do a keyword search on docstrings.

A list of objects that matched the search is displayed,

sorted by relevance. All given keywords need to be found in the
docstring for it to be returned as a result, but the order does
not matter.

Parameters
----------
what : str
String containing words to look for.
module : str or list, optional
Name of module(s) whose docstrings to go through.
import_modules : bool, optional
Whether to import sub-modules in packages. Default is True.
regenerate : bool, optional
Whether to re-generate the docstring cache. Default is False.
 output : file-like, optional
File-like object to write the output to. If omitted, use a pager.

See Also
--------
source, info

Notes
-----
Relevance is determined only roughly, by checking if the keywords occur
in the function name, at the start of a docstring, etc.

Examples
--------
>>> np.lookfor('binary representation') # doctest: +SKIP
Search results for 'binary representation'
------------------------------------------
numpy.binary_repr
Return the binary representation of the input number as a string.
numpy.core.setup_common.long_double_representation
Given a binary dump as given by GNU od -b, look for long double
numpy.base_repr
Return a string representation of a number in the given base system.
...

mask_indices(n, mask_func, k=0)

Return the indices to access (n, n) arrays, given a masking function.

Assume `mask_func` is a function that, for a square array a of size

``(n, n)`` with a possible offset argument `k`, when called as
``mask_func(a, k)`` returns a new array with zeros in certain locations
(functions like `triu` or `tril` do precisely this). Then this function
returns the indices where the non-zero values would be located.

Parameters
----------
n : int
The returned indices will be valid to access arrays of shape (n, n).
mask_func : callable
A function whose call signature is similar to that of `triu`, `tril`.
That is, ``mask_func(x, k)`` returns a boolean array, shaped like `x`.
`k` is an optional argument to the function.
k : scalar
An optional argument which is passed through to `mask_func`. Functions
like `triu`, `tril` take a second argument that is interpreted as an
offset.

Returns
-------
indices : tuple of arrays.
The `n` arrays of indices corresponding to the locations where
``mask_func(np.ones((n, n)), k)`` is True.

See Also
--------
triu, tril, triu_indices, tril_indices

Notes
-----
 .. versionadded:: 1.4.0

Examples
--------
These are the indices that would allow you to access the upper triangular
part of any 3x3 array:

>>> iu = np.mask_indices(3, np.triu)

For example, if `a` is a 3x3 array:

>>> a = np.arange(9).reshape(3, 3)
>>> a
array([[0, 1, 2],
[3, 4, 5],
[6, 7, 8]])
>>> a[iu]
array([0, 1, 2, 4, 5, 8])

An offset can be passed also to the masking function. This gets us the
indices starting on the first diagonal right of the main one:

>>> iu1 = np.mask_indices(3, np.triu, 1)

with which we now extract only three elements:

>>> a[iu1]
array([1, 2, 5])

mat = asmatrix(data, dtype=None)

Interpret the input as a matrix.

Unlike `matrix`, `asmatrix` does not make a copy if the input is already
a matrix or an ndarray. Equivalent to ``matrix(data, copy=False)``.

Parameters
----------
data : array_like
Input data.
dtype : data-type
Data-type of the output matrix.

Returns
-------
mat : matrix
`data` interpreted as a matrix.

Examples
--------
>>> x = np.array([[1, 2], [3, 4]])

>>> m = np.asmatrix(x)

>>> x[0,0] = 5

>>> m
matrix([[5, 2],
[3, 4]])
maximum_sctype(t)
Return the scalar type of highest precision of the same kind as the input.

Parameters
----------
t : dtype or dtype specifier
The input data type. This can be a `dtype` object or an object that
is convertible to a `dtype`.

Returns
-------
out : dtype
The highest precision data type of the same kind (`dtype.kind`) as `t`.

See Also
--------
obj2sctype, mintypecode, sctype2char
dtype

Examples
--------
>>> np.maximum_sctype(int)
<class 'numpy.int64'>
>>> np.maximum_sctype(np.uint8)
<class 'numpy.uint64'>
>>> np.maximum_sctype(complex)
<class 'numpy.complex256'> # may vary

>>> np.maximum_sctype(str)
<class 'numpy.str_'>

>>> np.maximum_sctype('i2')
<class 'numpy.int64'>
>>> np.maximum_sctype('f4')
<class 'numpy.float128'> # may vary

may_share_memory(...)
may_share_memory(a, b, /, max_work=None)

Determine if two arrays might share memory

A return of True does not necessarily mean that the two arrays
share any element. It just means that they *might*.

Only the memory bounds of a and b are checked by default.

Parameters
----------
a, b : ndarray
Input arrays
max_work : int, optional
Effort to spend on solving the overlap problem. See
`shares_memory` for details. Default for ``may_share_memory``
is to do a bounds check.

Returns
-------
out : bool
 See Also
--------
shares_memory

Examples
--------
>>> np.may_share_memory(np.array([1,2]), np.array([5,8,9]))
False
>>> x = np.zeros([3, 4])
>>> np.may_share_memory(x[:,0], x[:,1])
True

mean(a, axis=None, dtype=None, out=None, keepdims=<no value>, *, where=<no

value>)
Compute the arithmetic mean along the specified axis.

Returns the average of the array elements. The average is taken over
the flattened array by default, otherwise over the specified axis.
`float64` intermediate and return values are used for integer inputs.

Parameters
----------
a : array_like
Array containing numbers whose mean is desired. If `a` is not an
array, a conversion is attempted.
axis : None or int or tuple of ints, optional
Axis or axes along which the means are computed. The default is to
compute the mean of the flattened array.

.. versionadded:: 1.7.0

If this is a tuple of ints, a mean is performed over multiple axes,

instead of a single axis or all the axes as before.
dtype : data-type, optional
Type to use in computing the mean. For integer inputs, the default
is `float64`; for floating point inputs, it is the same as the
input dtype.
out : ndarray, optional
Alternate output array in which to place the result. The default
is ``None``; if provided, it must have the same shape as the
expected output, but the type will be cast if necessary.
See :ref:`ufuncs-output-type` for more details.

keepdims : bool, optional

If this is set to True, the axes which are reduced are left
in the result as dimensions with size one. With this option,
the result will broadcast correctly against the input array.

If the default value is passed, then `keepdims` will not be

passed through to the `mean` method of sub-classes of
`ndarray`, however any non-default value will be. If the
sub-class' method does not implement `keepdims` any
exceptions will be raised.

where : array_like of bool, optional

Elements to include in the mean. See `~numpy.ufunc.reduce` for details.

.. versionadded:: 1.20.0
 Returns
-------
m : ndarray, see dtype parameter above
If `out=None`, returns a new array containing the mean values,
otherwise a reference to the output array is returned.

See Also
--------
average : Weighted average
std, var, nanmean, nanstd, nanvar

Notes
-----
The arithmetic mean is the sum of the elements along the axis divided
by the number of elements.

Note that for floating-point input, the mean is computed using the
same precision the input has. Depending on the input data, this can
cause the results to be inaccurate, especially for `float32` (see
example below). Specifying a higher-precision accumulator using the
`dtype` keyword can alleviate this issue.

By default, `float16` results are computed using `float32` intermediates

for extra precision.

Examples
--------
>>> a = np.array([[1, 2], [3, 4]])
>>> np.mean(a)
2.5
>>> np.mean(a, axis=0)
array([2., 3.])
>>> np.mean(a, axis=1)
array([1.5, 3.5])

In single precision, `mean` can be inaccurate:

>>> a = np.zeros((2, 512*512), dtype=np.float32)

>>> a[0, :] = 1.0
>>> a[1, :] = 0.1
>>> np.mean(a)
0.54999924

Computing the mean in float64 is more accurate:

>>> np.mean(a, dtype=np.float64)

0.55000000074505806 # may vary

Specifying a where argument:

>>> a = np.array([[5, 9, 13], [14, 10, 12], [11, 15, 19]])

>>> np.mean(a)
12.0
>>> np.mean(a, where=[[True], [False], [False]])
9.0

median(a, axis=None, out=None, overwrite_input=False, keepdims=False)

Compute the median along the specified axis.
Returns the median of the array elements.

Parameters
----------
a : array_like
Input array or object that can be converted to an array.
axis : {int, sequence of int, None}, optional
Axis or axes along which the medians are computed. The default
is to compute the median along a flattened version of the array.
A sequence of axes is supported since version 1.9.0.
out : ndarray, optional
Alternative output array in which to place the result. It must
have the same shape and buffer length as the expected output,
but the type (of the output) will be cast if necessary.
overwrite_input : bool, optional
If True, then allow use of memory of input array `a` for
calculations. The input array will be modified by the call to
`median`. This will save memory when you do not need to preserve
the contents of the input array. Treat the input as undefined,
but it will probably be fully or partially sorted. Default is
False. If `overwrite_input` is ``True`` and `a` is not already an
`ndarray`, an error will be raised.
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.9.0

Returns
-------
median : ndarray
A new array holding the result. If the input contains integers
or floats smaller than ``float64``, then the output data-type is
``np.float64``. Otherwise, the data-type of the output is the
same as that of the input. If `out` is specified, that array is
returned instead.

See Also
--------
mean, percentile

Notes
-----
Given a vector ``V`` of length ``N``, the median of ``V`` is the
middle value of a sorted copy of ``V``, ``V_sorted`` - i
e., ``V_sorted[(N-1)/2]``, when ``N`` is odd, and the average of the
two middle values of ``V_sorted`` when ``N`` is even.

Examples
--------
>>> a = np.array([[10, 7, 4], [3, 2, 1]])
>>> a
array([[10, 7, 4],
[ 3, 2, 1]])
>>> np.median(a)
3.5
>>> np.median(a, axis=0)
array([6.5, 4.5, 2.5])
 >>> np.median(a, axis=1)
array([7., 2.])
>>> m = np.median(a, axis=0)
>>> out = np.zeros_like(m)
>>> np.median(a, axis=0, out=m)
array([6.5, 4.5, 2.5])
>>> m
array([6.5, 4.5, 2.5])
>>> b = a.copy()
>>> np.median(b, axis=1, overwrite_input=True)
array([7., 2.])
>>> assert not np.all(a==b)
>>> b = a.copy()
>>> np.median(b, axis=None, overwrite_input=True)
3.5
>>> assert not np.all(a==b)

meshgrid(*xi, copy=True, sparse=False, indexing='xy')

Return a list of coordinate matrices from coordinate vectors.

Make N-D coordinate arrays for vectorized evaluations of

N-D scalar/vector fields over N-D grids, given
one-dimensional coordinate arrays x1, x2,..., xn.

.. versionchanged:: 1.9
1-D and 0-D cases are allowed.

Parameters
----------
x1, x2,..., xn : array_like
1-D arrays representing the coordinates of a grid.
indexing : {'xy', 'ij'}, optional
Cartesian ('xy', default) or matrix ('ij') indexing of output.
See Notes for more details.

.. versionadded:: 1.7.0
sparse : bool, optional
If True the shape of the returned coordinate array for dimension *i*
is reduced from ``(N1, ..., Ni, ... Nn)`` to
``(1, ..., 1, Ni, 1, ..., 1)``. These sparse coordinate grids are
intended to be use with :ref:`basics.broadcasting`. When all
coordinates are used in an expression, broadcasting still leads to a
fully-dimensonal result array.

Default is False.

.. versionadded:: 1.7.0
copy : bool, optional
If False, a view into the original arrays are returned in order to
conserve memory. Default is True. Please note that
``sparse=False, copy=False`` will likely return non-contiguous
arrays. Furthermore, more than one element of a broadcast array
may refer to a single memory location. If you need to write to the
arrays, make copies first.

.. versionadded:: 1.7.0

Returns
-------
X1, X2,..., XN : list of ndarrays
For vectors `x1`, `x2`,..., `xn` with lengths ``Ni=len(xi)``,
returns ``(N1, N2, N3,..., Nn)`` shaped arrays if indexing='ij'
or ``(N2, N1, N3,..., Nn)`` shaped arrays if indexing='xy'
with the elements of `xi` repeated to fill the matrix along
the first dimension for `x1`, the second for `x2` and so on.

Notes
-----
This function supports both indexing conventions through the indexing
keyword argument. Giving the string 'ij' returns a meshgrid with
matrix indexing, while 'xy' returns a meshgrid with Cartesian indexing.
In the 2-D case with inputs of length M and N, the outputs are of shape
(N, M) for 'xy' indexing and (M, N) for 'ij' indexing. In the 3-D case
with inputs of length M, N and P, outputs are of shape (N, M, P) for
'xy' indexing and (M, N, P) for 'ij' indexing. The difference is
illustrated by the following code snippet::

xv, yv = np.meshgrid(x, y, indexing='ij')

for i in range(nx):
for j in range(ny):
# treat xv[i,j], yv[i,j]

xv, yv = np.meshgrid(x, y, indexing='xy')

for i in range(nx):
for j in range(ny):
# treat xv[j,i], yv[j,i]

In the 1-D and 0-D case, the indexing and sparse keywords have no effect.

See Also
--------
mgrid : Construct a multi-dimensional "meshgrid" using indexing notation.
ogrid : Construct an open multi-dimensional "meshgrid" using indexing
notation.
how-to-index

Examples
--------
>>> nx, ny = (3, 2)
>>> x = np.linspace(0, 1, nx)
>>> y = np.linspace(0, 1, ny)
>>> xv, yv = np.meshgrid(x, y)
>>> xv
array([[0. , 0.5, 1. ],
[0. , 0.5, 1. ]])
>>> yv
array([[0., 0., 0.],
[1., 1., 1.]])

The result of `meshgrid` is a coordinate grid:

>>> import matplotlib.pyplot as plt

>>> plt.plot(xv, yv, marker='o', color='k', linestyle='none')
>>> plt.show()

You can create sparse output arrays to save memory and computation time.

>>> xv, yv = np.meshgrid(x, y, sparse=True)

 >>> xv
array([[0. , 0.5, 1. ]])
>>> yv
array([[0.],
[1.]])

`meshgrid` is very useful to evaluate functions on a grid. If the

function depends on all coordinates, both dense and sparse outputs can be
used.

>>> x = np.linspace(-5, 5, 101)

>>> y = np.linspace(-5, 5, 101)
>>> # full coordinate arrays
>>> xx, yy = np.meshgrid(x, y)
>>> zz = np.sqrt(xx**2 + yy**2)
>>> xx.shape, yy.shape, zz.shape
((101, 101), (101, 101), (101, 101))
>>> # sparse coordinate arrays
>>> xs, ys = np.meshgrid(x, y, sparse=True)
>>> zs = np.sqrt(xs**2 + ys**2)
>>> xs.shape, ys.shape, zs.shape
((1, 101), (101, 1), (101, 101))
>>> np.array_equal(zz, zs)
True

>>> h = plt.contourf(x, y, zs)

>>> plt.axis('scaled')
>>> plt.colorbar()
>>> plt.show()

min_scalar_type(...)
min_scalar_type(a, /)

For scalar ``a``, returns the data type with the smallest size
and smallest scalar kind which can hold its value. For non-scalar
array ``a``, returns the vector's dtype unmodified.

Floating point values are not demoted to integers,

and complex values are not demoted to floats.

Parameters
----------
a : scalar or array_like
The value whose minimal data type is to be found.

Returns
-------
out : dtype
The minimal data type.

Notes
-----
.. versionadded:: 1.6.0

See Also
--------
result_type, promote_types, dtype, can_cast

Examples
 --------
>>> np.min_scalar_type(10)
dtype('uint8')

>>> np.min_scalar_type(-260)
dtype('int16')

>>> np.min_scalar_type(3.1)
dtype('float16')

>>> np.min_scalar_type(1e50)
dtype('float64')

>>> np.min_scalar_type(np.arange(4,dtype='f8'))
dtype('float64')

mintypecode(typechars, typeset='GDFgdf', default='d')

Return the character for the minimum-size type to which given types can
be safely cast.

The returned type character must represent the smallest size dtype such
that an array of the returned type can handle the data from an array of
all types in `typechars` (or if `typechars` is an array, then its
dtype.char).

Parameters
----------
typechars : list of str or array_like
If a list of strings, each string should represent a dtype.
If array_like, the character representation of the array dtype is used.
typeset : str or list of str, optional
The set of characters that the returned character is chosen from.
The default set is 'GDFgdf'.
default : str, optional
The default character, this is returned if none of the characters in
`typechars` matches a character in `typeset`.

Returns
-------
typechar : str
The character representing the minimum-size type that was found.

See Also
--------
dtype, sctype2char, maximum_sctype

Examples
--------
>>> np.mintypecode(['d', 'f', 'S'])
'd'
>>> x = np.array([1.1, 2-3.j])
>>> np.mintypecode(x)
'D'

>>> np.mintypecode('abceh', default='G')

'G'

moveaxis(a, source, destination)

Move axes of an array to new positions.
 Other axes remain in their original order.

.. versionadded:: 1.11.0

Parameters
----------
a : np.ndarray
The array whose axes should be reordered.
source : int or sequence of int
Original positions of the axes to move. These must be unique.
destination : int or sequence of int
Destination positions for each of the original axes. These must also be
unique.

Returns
-------
result : np.ndarray
Array with moved axes. This array is a view of the input array.

See Also
--------
transpose : Permute the dimensions of an array.
swapaxes : Interchange two axes of an array.

Examples
--------
>>> x = np.zeros((3, 4, 5))
>>> np.moveaxis(x, 0, -1).shape
(4, 5, 3)
>>> np.moveaxis(x, -1, 0).shape
(5, 3, 4)

These all achieve the same result:

>>> np.transpose(x).shape
(5, 4, 3)
>>> np.swapaxes(x, 0, -1).shape
(5, 4, 3)
>>> np.moveaxis(x, [0, 1], [-1, -2]).shape
(5, 4, 3)
>>> np.moveaxis(x, [0, 1, 2], [-1, -2, -3]).shape
(5, 4, 3)

msort(a)
Return a copy of an array sorted along the first axis.

.. deprecated:: 1.24

msort is deprecated, use ``np.sort(a, axis=0)`` instead.

Parameters
----------
a : array_like
Array to be sorted.

Returns
-------
sorted_array : ndarray
 Array of the same type and shape as `a`.

See Also
--------
sort

Notes
-----
``np.msort(a)`` is equivalent to ``np.sort(a, axis=0)``.

Examples
--------
>>> a = np.array([[1, 4], [3, 1]])
>>> np.msort(a) # sort along the first axis
array([[1, 1],
[3, 4]])

nan_to_num(x, copy=True, nan=0.0, posinf=None, neginf=None)

Replace NaN with zero and infinity with large finite numbers (default
behaviour) or with the numbers defined by the user using the `nan`,
`posinf` and/or `neginf` keywords.

If `x` is inexact, NaN is replaced by zero or by the user defined value in

`nan` keyword, infinity is replaced by the largest finite floating point
values representable by ``x.dtype`` or by the user defined value in
`posinf` keyword and -infinity is replaced by the most negative finite
floating point values representable by ``x.dtype`` or by the user defined
value in `neginf` keyword.

For complex dtypes, the above is applied to each of the real and
imaginary components of `x` separately.

If `x` is not inexact, then no replacements are made.

Parameters
----------
x : scalar or array_like
Input data.
copy : bool, optional
Whether to create a copy of `x` (True) or to replace values
in-place (False). The in-place operation only occurs if
casting to an array does not require a copy.
Default is True.

.. versionadded:: 1.13
nan : int, float, optional
Value to be used to fill NaN values. If no value is passed
then NaN values will be replaced with 0.0.

.. versionadded:: 1.17
posinf : int, float, optional
Value to be used to fill positive infinity values. If no value is
passed then positive infinity values will be replaced with a very
large number.

.. versionadded:: 1.17
neginf : int, float, optional
Value to be used to fill negative infinity values. If no value is
passed then negative infinity values will be replaced with a very
 small (or negative) number.

.. versionadded:: 1.17

Returns
-------
out : ndarray
`x`, with the non-finite values replaced. If `copy` is False, this may
be `x` itself.

See Also
--------
isinf : Shows which elements are positive or negative infinity.
isneginf : Shows which elements are negative infinity.
isposinf : Shows which elements are positive infinity.
isnan : Shows which elements are Not a Number (NaN).
isfinite : Shows which elements are finite (not NaN, not infinity)

Notes
-----
NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic
(IEEE 754). This means that Not a Number is not equivalent to infinity.

Examples
--------
>>> np.nan_to_num(np.inf)
1.7976931348623157e+308
>>> np.nan_to_num(-np.inf)
-1.7976931348623157e+308
>>> np.nan_to_num(np.nan)
0.0
>>> x = np.array([np.inf, -np.inf, np.nan, -128, 128])
>>> np.nan_to_num(x)
array([ 1.79769313e+308, -1.79769313e+308, 0.00000000e+000, # may vary
-1.28000000e+002, 1.28000000e+002])
>>> np.nan_to_num(x, nan=-9999, posinf=33333333, neginf=33333333)
array([ 3.3333333e+07, 3.3333333e+07, -9.9990000e+03,
-1.2800000e+02, 1.2800000e+02])
>>> y = np.array([complex(np.inf, np.nan), np.nan, complex(np.nan,
np.inf)])
array([ 1.79769313e+308, -1.79769313e+308, 0.00000000e+000, # may vary
-1.28000000e+002, 1.28000000e+002])
>>> np.nan_to_num(y)
array([ 1.79769313e+308 +0.00000000e+000j, # may vary
0.00000000e+000 +0.00000000e+000j,
0.00000000e+000 +1.79769313e+308j])
>>> np.nan_to_num(y, nan=111111, posinf=222222)
array([222222.+111111.j, 111111. +0.j, 111111.+222222.j])

nanargmax(a, axis=None, out=None, *, keepdims=<no value>)

Return the indices of the maximum values in the specified axis ignoring
NaNs. For all-NaN slices ``ValueError`` is raised. Warning: the
results cannot be trusted if a slice contains only NaNs and -Infs.

Parameters
----------
 a : array_like
Input data.
axis : int, optional
Axis along which to operate. By default flattened input is used.
out : array, optional
If provided, the result will be inserted into this array. It should
be of the appropriate shape and dtype.

.. versionadded:: 1.22.0
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 array.

.. versionadded:: 1.22.0

Returns
-------
index_array : ndarray
An array of indices or a single index value.

See Also
--------
argmax, nanargmin

Examples
--------
>>> a = np.array([[np.nan, 4], [2, 3]])
>>> np.argmax(a)
0
>>> np.nanargmax(a)
1
>>> np.nanargmax(a, axis=0)
array([1, 0])
>>> np.nanargmax(a, axis=1)
array([1, 1])

nanargmin(a, axis=None, out=None, *, keepdims=<no value>)

Return the indices of the minimum values in the specified axis ignoring
NaNs. For all-NaN slices ``ValueError`` is raised. Warning: the results
cannot be trusted if a slice contains only NaNs and Infs.

Parameters
----------
a : array_like
Input data.
axis : int, optional
Axis along which to operate. By default flattened input is used.
out : array, optional
If provided, the result will be inserted into this array. It should
be of the appropriate shape and dtype.

.. versionadded:: 1.22.0
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 array.

.. versionadded:: 1.22.0
 Returns
-------
index_array : ndarray
An array of indices or a single index value.

See Also
--------
argmin, nanargmax

Examples
--------
>>> a = np.array([[np.nan, 4], [2, 3]])
>>> np.argmin(a)
0
>>> np.nanargmin(a)
2
>>> np.nanargmin(a, axis=0)
array([1, 1])
>>> np.nanargmin(a, axis=1)
array([1, 0])

nancumprod(a, axis=None, dtype=None, out=None)

Return the cumulative product of array elements over a given axis treating
Not a
Numbers (NaNs) as one. The cumulative product does not change when NaNs
are
encountered and leading NaNs are replaced by ones.

Ones are returned for slices that are all-NaN or empty.

.. versionadded:: 1.12.0

Parameters
----------
a : array_like
Input array.
axis : int, optional
Axis along which the cumulative product is computed. By default
the input is flattened.
dtype : dtype, optional
Type of the returned array, as well as of the accumulator in which
the elements are multiplied. If *dtype* is not specified, it
defaults to the dtype of `a`, unless `a` has an integer dtype with
a precision less than that of the default platform integer. In
that case, the default platform integer is used instead.
out : ndarray, optional
Alternative output array in which to place the result. It must
have the same shape and buffer length as the expected output
but the type of the resulting values will be cast if necessary.

Returns
-------
nancumprod : ndarray
A new array holding the result is returned unless `out` is
specified, in which case it is returned.

See Also
--------
 numpy.cumprod : Cumulative product across array propagating NaNs.
isnan : Show which elements are NaN.

Examples
--------
>>> np.nancumprod(1)
array([1])
>>> np.nancumprod([1])
array([1])
>>> np.nancumprod([1, np.nan])
array([1., 1.])
>>> a = np.array([[1, 2], [3, np.nan]])
>>> np.nancumprod(a)
array([1., 2., 6., 6.])
>>> np.nancumprod(a, axis=0)
array([[1., 2.],
[3., 2.]])
>>> np.nancumprod(a, axis=1)
array([[1., 2.],
[3., 3.]])

nancumsum(a, axis=None, dtype=None, out=None)

Return the cumulative sum of array elements over a given axis treating Not
a
Numbers (NaNs) as zero. The cumulative sum does not change when NaNs are
encountered and leading NaNs are replaced by zeros.

Zeros are returned for slices that are all-NaN or empty.

.. versionadded:: 1.12.0

Parameters
----------
a : array_like
Input array.
axis : int, optional
Axis along which the cumulative sum is computed. The default
(None) is to compute the cumsum over the flattened array.
dtype : dtype, optional
Type of the returned array and of the accumulator in which the
elements are summed. If `dtype` is not specified, it defaults
to the dtype of `a`, unless `a` has an integer dtype with a
precision less than that of the default platform integer. In
that case, the default platform integer is used.
out : ndarray, optional
Alternative output array in which to place the result. It must
have the same shape and buffer length as the expected output
but the type will be cast if necessary. See :ref:`ufuncs-output-type`
for
more details.

Returns
-------
nancumsum : ndarray.
A new array holding the result is returned unless `out` is
specified, in which it is returned. The result has the same
size as `a`, and the same shape as `a` if `axis` is not None
or `a` is a 1-d array.
 See Also
--------
numpy.cumsum : Cumulative sum across array propagating NaNs.
isnan : Show which elements are NaN.

Examples
--------
>>> np.nancumsum(1)
array([1])
>>> np.nancumsum([1])
array([1])
>>> np.nancumsum([1, np.nan])
array([1., 1.])
>>> a = np.array([[1, 2], [3, np.nan]])
>>> np.nancumsum(a)
array([1., 3., 6., 6.])
>>> np.nancumsum(a, axis=0)
array([[1., 2.],
[4., 2.]])
>>> np.nancumsum(a, axis=1)
array([[1., 3.],
[3., 3.]])

nanmax(a, axis=None, out=None, keepdims=<no value>, initial=<no value>,

where=<no value>)
Return the maximum of an array or maximum along an axis, ignoring any
NaNs. When all-NaN slices are encountered a ``RuntimeWarning`` is
raised and NaN is returned for that slice.

Parameters
----------
a : array_like
Array containing numbers whose maximum is desired. If `a` is not an
array, a conversion is attempted.
axis : {int, tuple of int, None}, optional
Axis or axes along which the maximum is computed. The default is to
compute
the maximum of the flattened array.
out : ndarray, optional
Alternate output array in which to place the result. The default
is ``None``; if provided, it must have the same shape as the
expected output, but the type will be cast if necessary. See
:ref:`ufuncs-output-type` for more details.

.. versionadded:: 1.8.0
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 `a`.

If the value is anything but the default, then

`keepdims` will be passed through to the `max` method
of sub-classes of `ndarray`. If the sub-classes methods
does not implement `keepdims` any exceptions will be raised.

.. versionadded:: 1.8.0
initial : scalar, optional
The minimum value of an output element. Must be present to allow
computation on empty slice. See `~numpy.ufunc.reduce` for details.
 .. versionadded:: 1.22.0
where : array_like of bool, optional
Elements to compare for the maximum. See `~numpy.ufunc.reduce`
for details.

.. versionadded:: 1.22.0

Returns
-------
nanmax : ndarray
An array with the same shape as `a`, with the specified axis removed.
If `a` is a 0-d array, or if axis is None, an ndarray scalar is
returned. The same dtype as `a` is returned.

See Also
--------
nanmin :
The minimum value of an array along a given axis, ignoring any NaNs.
amax :
The maximum value of an array along a given axis, propagating any NaNs.
fmax :
Element-wise maximum of two arrays, ignoring any NaNs.
maximum :
Element-wise maximum of two arrays, propagating any NaNs.
isnan :
Shows which elements are Not a Number (NaN).
isfinite:
Shows which elements are neither NaN nor infinity.

amin, fmin, minimum

Notes
-----
NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic
(IEEE 754). This means that Not a Number is not equivalent to infinity.
Positive infinity is treated as a very large number and negative
infinity is treated as a very small (i.e. negative) number.

If the input has a integer type the function is equivalent to np.max.

Examples
--------
>>> a = np.array([[1, 2], [3, np.nan]])
>>> np.nanmax(a)
3.0
>>> np.nanmax(a, axis=0)
array([3., 2.])
>>> np.nanmax(a, axis=1)
array([2., 3.])

When positive infinity and negative infinity are present:

>>> np.nanmax([1, 2, np.nan, np.NINF])

2.0
>>> np.nanmax([1, 2, np.nan, np.inf])
inf

nanmean(a, axis=None, dtype=None, out=None, keepdims=<no value>, *, where=<no

value>)
Compute the arithmetic mean along the specified axis, ignoring NaNs.

Returns the average of the array elements. The average is taken over
the flattened array by default, otherwise over the specified axis.
`float64` intermediate and return values are used for integer inputs.

For all-NaN slices, NaN is returned and a `RuntimeWarning` is raised.

.. versionadded:: 1.8.0

Parameters
----------
a : array_like
Array containing numbers whose mean is desired. If `a` is not an
array, a conversion is attempted.
axis : {int, tuple of int, None}, optional
Axis or axes along which the means are computed. The default is to
compute
the mean of the flattened array.
dtype : data-type, optional
Type to use in computing the mean. For integer inputs, the default
is `float64`; for inexact inputs, it is the same as the input
dtype.
out : ndarray, optional
Alternate output array in which to place the result. The default
is ``None``; if provided, it must have the same shape as the
expected output, but the type will be cast if necessary. See
:ref:`ufuncs-output-type` for more details.
keepdims : bool, optional
If this is set to True, the axes which are reduced are left
in the result as dimensions with size one. With this option,
the result will broadcast correctly against the original `a`.

If the value is anything but the default, then

`keepdims` will be passed through to the `mean` or `sum` methods
of sub-classes of `ndarray`. If the sub-classes methods
does not implement `keepdims` any exceptions will be raised.
where : array_like of bool, optional
Elements to include in the mean. See `~numpy.ufunc.reduce` for details.

.. versionadded:: 1.22.0

Returns
-------
m : ndarray, see dtype parameter above
If `out=None`, returns a new array containing the mean values,
otherwise a reference to the output array is returned. Nan is
returned for slices that contain only NaNs.

See Also
--------
average : Weighted average
mean : Arithmetic mean taken while not ignoring NaNs
var, nanvar

Notes
-----
The arithmetic mean is the sum of the non-NaN elements along the axis
 divided by the number of non-NaN elements.

Note that for floating-point input, the mean is computed using the same
precision the input has. Depending on the input data, this can cause
the results to be inaccurate, especially for `float32`. Specifying a
higher-precision accumulator using the `dtype` keyword can alleviate
this issue.

Examples
--------
>>> a = np.array([[1, np.nan], [3, 4]])
>>> np.nanmean(a)
2.6666666666666665
>>> np.nanmean(a, axis=0)
array([2., 4.])
>>> np.nanmean(a, axis=1)
array([1., 3.5]) # may vary

nanmedian(a, axis=None, out=None, overwrite_input=False, keepdims=<no value>)

Compute the median along the specified axis, while ignoring NaNs.

Returns the median of the array elements.

.. versionadded:: 1.9.0

Parameters
----------
a : array_like
Input array or object that can be converted to an array.
axis : {int, sequence of int, None}, optional
Axis or axes along which the medians are computed. The default
is to compute the median along a flattened version of the array.
A sequence of axes is supported since version 1.9.0.
out : ndarray, optional
Alternative output array in which to place the result. It must
have the same shape and buffer length as the expected output,
but the type (of the output) will be cast if necessary.
overwrite_input : bool, optional
If True, then allow use of memory of input array `a` for
calculations. The input array will be modified by the call to
`median`. This will save memory when you do not need to preserve
the contents of the input array. Treat the input as undefined,
but it will probably be fully or partially sorted. Default is
False. If `overwrite_input` is ``True`` and `a` is not already an
`ndarray`, an error will be raised.
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 `a`.

If this is anything but the default value it will be passed

through (in the special case of an empty array) to the
`mean` function of the underlying array. If the array is
a sub-class and `mean` does not have the kwarg `keepdims` this
will raise a RuntimeError.

Returns
-------
median : ndarray
 A new array holding the result. If the input contains integers
or floats smaller than ``float64``, then the output data-type is
``np.float64``. Otherwise, the data-type of the output is the
same as that of the input. If `out` is specified, that array is
returned instead.

See Also
--------
mean, median, percentile

Notes
-----
Given a vector ``V`` of length ``N``, the median of ``V`` is the
middle value of a sorted copy of ``V``, ``V_sorted`` - i.e.,
``V_sorted[(N-1)/2]``, when ``N`` is odd and the average of the two
middle values of ``V_sorted`` when ``N`` is even.

Examples
--------
>>> a = np.array([[10.0, 7, 4], [3, 2, 1]])
>>> a[0, 1] = np.nan
>>> a
array([[10., nan, 4.],
[ 3., 2., 1.]])
>>> np.median(a)
nan
>>> np.nanmedian(a)
3.0
>>> np.nanmedian(a, axis=0)
array([6.5, 2. , 2.5])
>>> np.median(a, axis=1)
array([nan, 2.])
>>> b = a.copy()
>>> np.nanmedian(b, axis=1, overwrite_input=True)
array([7., 2.])
>>> assert not np.all(a==b)
>>> b = a.copy()
>>> np.nanmedian(b, axis=None, overwrite_input=True)
3.0
>>> assert not np.all(a==b)

nanmin(a, axis=None, out=None, keepdims=<no value>, initial=<no value>,

where=<no value>)
Return minimum of an array or minimum along an axis, ignoring any NaNs.
When all-NaN slices are encountered a ``RuntimeWarning`` is raised and
Nan is returned for that slice.

Parameters
----------
a : array_like
Array containing numbers whose minimum is desired. If `a` is not an
array, a conversion is attempted.
axis : {int, tuple of int, None}, optional
Axis or axes along which the minimum is computed. The default is to
compute
the minimum of the flattened array.
out : ndarray, optional
Alternate output array in which to place the result. The default
is ``None``; if provided, it must have the same shape as the
 expected output, but the type will be cast if necessary. See
:ref:`ufuncs-output-type` for more details.

.. versionadded:: 1.8.0
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 `a`.

If the value is anything but the default, then

`keepdims` will be passed through to the `min` method
of sub-classes of `ndarray`. If the sub-classes methods
does not implement `keepdims` any exceptions will be raised.

.. versionadded:: 1.8.0
initial : scalar, optional
The maximum value of an output element. Must be present to allow
computation on empty slice. See `~numpy.ufunc.reduce` for details.

.. versionadded:: 1.22.0
where : array_like of bool, optional
Elements to compare for the minimum. See `~numpy.ufunc.reduce`
for details.

.. versionadded:: 1.22.0

Returns
-------
nanmin : ndarray
An array with the same shape as `a`, with the specified axis
removed. If `a` is a 0-d array, or if axis is None, an ndarray
scalar is returned. The same dtype as `a` is returned.

See Also
--------
nanmax :
The maximum value of an array along a given axis, ignoring any NaNs.
amin :
The minimum value of an array along a given axis, propagating any NaNs.
fmin :
Element-wise minimum of two arrays, ignoring any NaNs.
minimum :
Element-wise minimum of two arrays, propagating any NaNs.
isnan :
Shows which elements are Not a Number (NaN).
isfinite:
Shows which elements are neither NaN nor infinity.

amax, fmax, maximum

Notes
-----
NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic
(IEEE 754). This means that Not a Number is not equivalent to infinity.
Positive infinity is treated as a very large number and negative
infinity is treated as a very small (i.e. negative) number.

If the input has a integer type the function is equivalent to np.min.

 Examples
--------
>>> a = np.array([[1, 2], [3, np.nan]])
>>> np.nanmin(a)
1.0
>>> np.nanmin(a, axis=0)
array([1., 2.])
>>> np.nanmin(a, axis=1)
array([1., 3.])

When positive infinity and negative infinity are present:

>>> np.nanmin([1, 2, np.nan, np.inf])

1.0
>>> np.nanmin([1, 2, np.nan, np.NINF])
-inf

nanpercentile(a, q, axis=None, out=None, overwrite_input=False,

method='linear', keepdims=<no value>, *, interpolation=None)
Compute the qth percentile of the data along the specified axis,
while ignoring nan values.

Returns the qth percentile(s) of the array elements.

.. versionadded:: 1.9.0

Parameters
----------
a : array_like
Input array or object that can be converted to an array, containing
nan values to be ignored.
q : array_like of float
Percentile or sequence of percentiles to compute, which must be
between 0 and 100 inclusive.
axis : {int, tuple of int, None}, optional
Axis or axes along which the percentiles are computed. The default
is to compute the percentile(s) along a flattened version of the
array.
out : ndarray, optional
Alternative output array in which to place the result. It must have
the same shape and buffer length as the expected output, but the
type (of the output) will be cast if necessary.
overwrite_input : bool, optional
If True, then allow the input array `a` to be modified by
intermediate calculations, to save memory. In this case, the
contents of the input `a` after this function completes is
undefined.
method : str, optional
This parameter specifies the method to use for estimating the
percentile. There are many different methods, some unique to NumPy.
See the notes for explanation. The options sorted by their R type
as summarized in the H&F paper [1]_ are:

1. 'inverted_cdf'
2. 'averaged_inverted_cdf'
3. 'closest_observation'
4. 'interpolated_inverted_cdf'
5. 'hazen'
6. 'weibull'
 7. 'linear' (default)
8. 'median_unbiased'
9. 'normal_unbiased'

The first three methods are discontinuous. NumPy further defines the
following discontinuous variations of the default 'linear' (7.) option:

* 'lower'
* 'higher',
* 'midpoint'
* 'nearest'

.. versionchanged:: 1.22.0
This argument was previously called "interpolation" and only
offered the "linear" default and last four options.

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 array `a`.

If this is anything but the default value it will be passed

through (in the special case of an empty array) to the
`mean` function of the underlying array. If the array is
a sub-class and `mean` does not have the kwarg `keepdims` this
will raise a RuntimeError.

interpolation : str, optional

Deprecated name for the method keyword argument.

.. deprecated:: 1.22.0

Returns
-------
percentile : scalar or ndarray
If `q` is a single percentile and `axis=None`, then the result
is a scalar. If multiple percentiles are given, first axis of
the result corresponds to the percentiles. The other axes are
the axes that remain after the reduction of `a`. If the input
contains integers or floats smaller than ``float64``, the output
data-type is ``float64``. Otherwise, the output data-type is the
same as that of the input. If `out` is specified, that array is
returned instead.

See Also
--------
nanmean
nanmedian : equivalent to ``nanpercentile(..., 50)``
percentile, median, mean
nanquantile : equivalent to nanpercentile, except q in range [0, 1].

Notes
-----
For more information please see `numpy.percentile`

Examples
--------
>>> a = np.array([[10., 7., 4.], [3., 2., 1.]])
>>> a[0][1] = np.nan
 >>> a
array([[10., nan, 4.],
[ 3., 2., 1.]])
>>> np.percentile(a, 50)
nan
>>> np.nanpercentile(a, 50)
3.0
>>> np.nanpercentile(a, 50, axis=0)
array([6.5, 2. , 2.5])
>>> np.nanpercentile(a, 50, axis=1, keepdims=True)
array([[7.],
[2.]])
>>> m = np.nanpercentile(a, 50, axis=0)
>>> out = np.zeros_like(m)
>>> np.nanpercentile(a, 50, axis=0, out=out)
array([6.5, 2. , 2.5])
>>> m
array([6.5, 2. , 2.5])

>>> b = a.copy()
>>> np.nanpercentile(b, 50, axis=1, overwrite_input=True)
array([7., 2.])
>>> assert not np.all(a==b)

References
----------
.. [1] R. J. Hyndman and Y. Fan,
"Sample quantiles in statistical packages,"
The American Statistician, 50(4), pp. 361-365, 1996

nanprod(a, axis=None, dtype=None, out=None, keepdims=<no value>, initial=<no

value>, where=<no value>)
Return the product of array elements over a given axis treating Not a
Numbers (NaNs) as ones.

One is returned for slices that are all-NaN or empty.

.. versionadded:: 1.10.0

Parameters
----------
a : array_like
Array containing numbers whose product is desired. If `a` is not an
array, a conversion is attempted.
axis : {int, tuple of int, None}, optional
Axis or axes along which the product is computed. The default is to
compute
the product of the flattened array.
dtype : data-type, optional
The type of the returned array and of the accumulator in which the
elements are summed. By default, the dtype of `a` is used. An
exception is when `a` has an integer type with less precision than
the platform (u)intp. In that case, the default will be either
(u)int32 or (u)int64 depending on whether the platform is 32 or 64
bits. For inexact inputs, dtype must be inexact.
out : ndarray, optional
Alternate output array in which to place the result. The default
is ``None``. If provided, it must have the same shape as the
expected output, but the type will be cast if necessary. See
 :ref:`ufuncs-output-type` for more details. The casting of NaN to
integer
can yield unexpected results.
keepdims : bool, optional
If 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`.
initial : scalar, optional
The starting value for this product. See `~numpy.ufunc.reduce`
for details.

.. versionadded:: 1.22.0
where : array_like of bool, optional
Elements to include in the product. See `~numpy.ufunc.reduce`
for details.

.. versionadded:: 1.22.0

Returns
-------
nanprod : ndarray
A new array holding the result is returned unless `out` is
specified, in which case it is returned.

See Also
--------
numpy.prod : Product across array propagating NaNs.
isnan : Show which elements are NaN.

Examples
--------
>>> np.nanprod(1)
1
>>> np.nanprod([1])
1
>>> np.nanprod([1, np.nan])
1.0
>>> a = np.array([[1, 2], [3, np.nan]])
>>> np.nanprod(a)
6.0
>>> np.nanprod(a, axis=0)
array([3., 2.])

nanquantile(a, q, axis=None, out=None, overwrite_input=False, method='linear',

keepdims=<no value>, *, interpolation=None)
Compute the qth quantile of the data along the specified axis,
while ignoring nan values.
Returns the qth quantile(s) of the array elements.

.. versionadded:: 1.15.0

Parameters
----------
a : array_like
Input array or object that can be converted to an array, containing
nan values to be ignored
q : array_like of float
Probability or sequence of probabilities for the quantiles to compute.
Values must be between 0 and 1 inclusive.
axis : {int, tuple of int, None}, optional
Axis or axes along which the quantiles are computed. The
default is to compute the quantile(s) along a flattened
version of the array.
out : ndarray, optional
Alternative output array in which to place the result. It must
have the same shape and buffer length as the expected output,
but the type (of the output) will be cast if necessary.
overwrite_input : bool, optional
If True, then allow the input array `a` to be modified by intermediate
calculations, to save memory. In this case, the contents of the input
`a` after this function completes is undefined.
method : str, optional
This parameter specifies the method to use for estimating the
quantile. There are many different methods, some unique to NumPy.
See the notes for explanation. The options sorted by their R type
as summarized in the H&F paper [1]_ are:

1. 'inverted_cdf'
2. 'averaged_inverted_cdf'
3. 'closest_observation'
4. 'interpolated_inverted_cdf'
5. 'hazen'
6. 'weibull'
7. 'linear' (default)
8. 'median_unbiased'
9. 'normal_unbiased'

The first three methods are discontinuous. NumPy further defines the
following discontinuous variations of the default 'linear' (7.) option:

* 'lower'
* 'higher',
* 'midpoint'
* 'nearest'

.. versionchanged:: 1.22.0
This argument was previously called "interpolation" and only
offered the "linear" default and last four options.

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 array `a`.

If this is anything but the default value it will be passed

through (in the special case of an empty array) to the
`mean` function of the underlying array. If the array is
a sub-class and `mean` does not have the kwarg `keepdims` this
will raise a RuntimeError.

interpolation : str, optional

Deprecated name for the method keyword argument.

.. deprecated:: 1.22.0

Returns
-------
quantile : scalar or ndarray
 If `q` is a single probability and `axis=None`, then the result
is a scalar. If multiple probability levels are given, first axis of
the result corresponds to the quantiles. The other axes are
the axes that remain after the reduction of `a`. If the input
contains integers or floats smaller than ``float64``, the output
data-type is ``float64``. Otherwise, the output data-type is the
same as that of the input. If `out` is specified, that array is
returned instead.

See Also
--------
quantile
nanmean, nanmedian
nanmedian : equivalent to ``nanquantile(..., 0.5)``
nanpercentile : same as nanquantile, but with q in the range [0, 100].

Notes
-----
For more information please see `numpy.quantile`

Examples
--------
>>> a = np.array([[10., 7., 4.], [3., 2., 1.]])
>>> a[0][1] = np.nan
>>> a
array([[10., nan, 4.],
[ 3., 2., 1.]])
>>> np.quantile(a, 0.5)
nan
>>> np.nanquantile(a, 0.5)
3.0
>>> np.nanquantile(a, 0.5, axis=0)
array([6.5, 2. , 2.5])
>>> np.nanquantile(a, 0.5, axis=1, keepdims=True)
array([[7.],
[2.]])
>>> m = np.nanquantile(a, 0.5, axis=0)
>>> out = np.zeros_like(m)
>>> np.nanquantile(a, 0.5, axis=0, out=out)
array([6.5, 2. , 2.5])
>>> m
array([6.5, 2. , 2.5])
>>> b = a.copy()
>>> np.nanquantile(b, 0.5, axis=1, overwrite_input=True)
array([7., 2.])
>>> assert not np.all(a==b)

References
----------
.. [1] R. J. Hyndman and Y. Fan,
"Sample quantiles in statistical packages,"
The American Statistician, 50(4), pp. 361-365, 1996

nanstd(a, axis=None, dtype=None, out=None, ddof=0, keepdims=<no value>, *,

where=<no value>)
Compute the standard deviation along the specified axis, while
ignoring NaNs.

Returns the standard deviation, a measure of the spread of a

 distribution, of the non-NaN array elements. The standard deviation is
computed for the flattened array by default, otherwise over the
specified axis.

For all-NaN slices or slices with zero degrees of freedom, NaN is

returned and a `RuntimeWarning` is raised.

.. versionadded:: 1.8.0

Parameters
----------
a : array_like
Calculate the standard deviation of the non-NaN values.
axis : {int, tuple of int, None}, optional
Axis or axes along which the standard deviation is computed. The
default is
to compute the standard deviation of the flattened array.
dtype : dtype, optional
Type to use in computing the standard deviation. For arrays of
integer type the default is float64, for arrays of float types it
is the same as the array type.
out : ndarray, optional
Alternative output array in which to place the result. It must have
the same shape as the expected output but the type (of the
calculated values) will be cast if necessary.
ddof : int, optional
Means Delta Degrees of Freedom. The divisor used in calculations
is ``N - ddof``, where ``N`` represents the number of non-NaN
elements. By default `ddof` is zero.

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 `a`.

If this value is anything but the default it is passed through

as-is to the relevant functions of the sub-classes. If these
functions do not have a `keepdims` kwarg, a RuntimeError will
be raised.
where : array_like of bool, optional
Elements to include in the standard deviation.
See `~numpy.ufunc.reduce` for details.

.. versionadded:: 1.22.0

Returns
-------
standard_deviation : ndarray, see dtype parameter above.
If `out` is None, return a new array containing the standard
deviation, otherwise return a reference to the output array. If
ddof is >= the number of non-NaN elements in a slice or the slice
contains only NaNs, then the result for that slice is NaN.

See Also
--------
var, mean, std
nanvar, nanmean
:ref:`ufuncs-output-type`
 Notes
-----
The standard deviation is the square root of the average of the squared
deviations from the mean: ``std = sqrt(mean(abs(x - x.mean())**2))``.

The average squared deviation is normally calculated as

``x.sum() / N``, where ``N = len(x)``. If, however, `ddof` is
specified, the divisor ``N - ddof`` is used instead. In standard
statistical practice, ``ddof=1`` provides an unbiased estimator of the
variance of the infinite population. ``ddof=0`` provides a maximum
likelihood estimate of the variance for normally distributed variables.
The standard deviation computed in this function is the square root of
the estimated variance, so even with ``ddof=1``, it will not be an
unbiased estimate of the standard deviation per se.

Note that, for complex numbers, `std` takes the absolute value before
squaring, so that the result is always real and nonnegative.

For floating-point input, the *std* is computed using the same

precision the input has. Depending on the input data, this can cause
the results to be inaccurate, especially for float32 (see example
below). Specifying a higher-accuracy accumulator using the `dtype`
keyword can alleviate this issue.

Examples
--------
>>> a = np.array([[1, np.nan], [3, 4]])
>>> np.nanstd(a)
1.247219128924647
>>> np.nanstd(a, axis=0)
array([1., 0.])
>>> np.nanstd(a, axis=1)
array([0., 0.5]) # may vary

nansum(a, axis=None, dtype=None, out=None, keepdims=<no value>, initial=<no

value>, where=<no value>)
Return the sum of array elements over a given axis treating Not a
Numbers (NaNs) as zero.

In NumPy versions <= 1.9.0 Nan is returned for slices that are all-NaN or
empty. In later versions zero is returned.

Parameters
----------
a : array_like
Array containing numbers whose sum is desired. If `a` is not an
array, a conversion is attempted.
axis : {int, tuple of int, None}, optional
Axis or axes along which the sum is computed. The default is to compute
the
sum of the flattened array.
dtype : data-type, optional
The type of the returned array and of the accumulator in which the
elements are summed. By default, the dtype of `a` is used. An
exception is when `a` has an integer type with less precision than
the platform (u)intp. In that case, the default will be either
(u)int32 or (u)int64 depending on whether the platform is 32 or 64
bits. For inexact inputs, dtype must be inexact.
 .. versionadded:: 1.8.0
out : ndarray, optional
Alternate output array in which to place the result. The default
is ``None``. If provided, it must have the same shape as the
expected output, but the type will be cast if necessary. See
:ref:`ufuncs-output-type` for more details. The casting of NaN to
integer
can yield unexpected results.

.. versionadded:: 1.8.0
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 `a`.

If the value is anything but the default, then

`keepdims` will be passed through to the `mean` or `sum` methods
of sub-classes of `ndarray`. If the sub-classes methods
does not implement `keepdims` any exceptions will be raised.

.. versionadded:: 1.8.0
initial : scalar, optional
Starting value for the sum. See `~numpy.ufunc.reduce` for details.

.. versionadded:: 1.22.0
where : array_like of bool, optional
Elements to include in the sum. See `~numpy.ufunc.reduce` for details.

.. versionadded:: 1.22.0

Returns
-------
nansum : ndarray.
A new array holding the result is returned unless `out` is
specified, in which it is returned. The result has the same
size as `a`, and the same shape as `a` if `axis` is not None
or `a` is a 1-d array.

See Also
--------
numpy.sum : Sum across array propagating NaNs.
isnan : Show which elements are NaN.
isfinite : Show which elements are not NaN or +/-inf.

Notes
-----
If both positive and negative infinity are present, the sum will be Not
A Number (NaN).

Examples
--------
>>> np.nansum(1)
1
>>> np.nansum([1])
1
>>> np.nansum([1, np.nan])
1.0
>>> a = np.array([[1, 1], [1, np.nan]])
 >>> np.nansum(a)
3.0
>>> np.nansum(a, axis=0)
array([2., 1.])
>>> np.nansum([1, np.nan, np.inf])
inf
>>> np.nansum([1, np.nan, np.NINF])
-inf
>>> from numpy.testing import suppress_warnings
>>> with suppress_warnings() as sup:
... sup.filter(RuntimeWarning)
... np.nansum([1, np.nan, np.inf, -np.inf]) # both +/- infinity present
nan

nanvar(a, axis=None, dtype=None, out=None, ddof=0, keepdims=<no value>, *,

where=<no value>)
Compute the variance along the specified axis, while ignoring NaNs.

Returns the variance of the array elements, a measure of the spread of

a distribution. The variance is computed for the flattened array by
default, otherwise over the specified axis.

For all-NaN slices or slices with zero degrees of freedom, NaN is

returned and a `RuntimeWarning` is raised.

.. versionadded:: 1.8.0

Parameters
----------
a : array_like
Array containing numbers whose variance is desired. If `a` is not an
array, a conversion is attempted.
axis : {int, tuple of int, None}, optional
Axis or axes along which the variance is computed. The default is to
compute
the variance of the flattened array.
dtype : data-type, optional
Type to use in computing the variance. For arrays of integer type
the default is `float64`; for arrays of float types it is the same as
the array type.
out : ndarray, optional
Alternate output array in which to place the result. It must have
the same shape as the expected output, but the type is cast if
necessary.
ddof : int, optional
"Delta Degrees of Freedom": the divisor used in the calculation is
``N - ddof``, where ``N`` represents the number of non-NaN
elements. By default `ddof` is zero.
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 `a`.
where : array_like of bool, optional
Elements to include in the variance. See `~numpy.ufunc.reduce` for
details.

.. versionadded:: 1.22.0

Returns
 -------
variance : ndarray, see dtype parameter above
If `out` is None, return a new array containing the variance,
otherwise return a reference to the output array. If ddof is >= the
number of non-NaN elements in a slice or the slice contains only
NaNs, then the result for that slice is NaN.

See Also
--------
std : Standard deviation
mean : Average
var : Variance while not ignoring NaNs
nanstd, nanmean
:ref:`ufuncs-output-type`

Notes
-----
The variance is the average of the squared deviations from the mean,
i.e., ``var = mean(abs(x - x.mean())**2)``.

The mean is normally calculated as ``x.sum() / N``, where ``N = len(x)``.

If, however, `ddof` is specified, the divisor ``N - ddof`` is used
instead. In standard statistical practice, ``ddof=1`` provides an
unbiased estimator of the variance of a hypothetical infinite
population. ``ddof=0`` provides a maximum likelihood estimate of the
variance for normally distributed variables.

Note that for complex numbers, the absolute value is taken before
squaring, so that the result is always real and nonnegative.

For floating-point input, the variance is computed using the same

precision the input has. Depending on the input data, this can cause
the results to be inaccurate, especially for `float32` (see example
below). Specifying a higher-accuracy accumulator using the ``dtype``
keyword can alleviate this issue.

For this function to work on sub-classes of ndarray, they must define

`sum` with the kwarg `keepdims`

Examples
--------
>>> a = np.array([[1, np.nan], [3, 4]])
>>> np.nanvar(a)
1.5555555555555554
>>> np.nanvar(a, axis=0)
array([1., 0.])
>>> np.nanvar(a, axis=1)
array([0., 0.25]) # may vary

ndim(a)
Return the number of dimensions of an array.

Parameters
----------
a : array_like
Input array. If it is not already an ndarray, a conversion is
attempted.

Returns
 -------
number_of_dimensions : int
The number of dimensions in `a`. Scalars are zero-dimensional.

See Also
--------
ndarray.ndim : equivalent method
shape : dimensions of array
ndarray.shape : dimensions of array

Examples
--------
>>> np.ndim([[1,2,3],[4,5,6]])
2
>>> np.ndim(np.array([[1,2,3],[4,5,6]]))
2
>>> np.ndim(1)
0

nested_iters(...)
nested_iters(op, axes, flags=None, op_flags=None, op_dtypes=None,
order="K", casting="safe", buffersize=0)

Create nditers for use in nested loops

Create a tuple of `nditer` objects which iterate in nested loops over

different axes of the op argument. The first iterator is used in the
outermost loop, the last in the innermost loop. Advancing one will change
the subsequent iterators to point at its new element.

Parameters
----------
op : ndarray or sequence of array_like
The array(s) to iterate over.

axes : list of list of int

Each item is used as an "op_axes" argument to an nditer

flags, op_flags, op_dtypes, order, casting, buffersize (optional)

See `nditer` parameters of the same name

Returns
-------
iters : tuple of nditer
An nditer for each item in `axes`, outermost first

See Also
--------
nditer

Examples
--------

Basic usage. Note how y is the "flattened" version of

[a[:, 0, :], a[:, 1, 0], a[:, 2, :]] since we specified
the first iter's axes as [1]

>>> a = np.arange(12).reshape(2, 3, 2)
>>> i, j = np.nested_iters(a, [[1], [0, 2]], flags=["multi_index"])
 >>> for x in i:
... print(i.multi_index)
... for y in j:
... print('', j.multi_index, y)
(0,)
(0, 0) 0
(0, 1) 1
(1, 0) 6
(1, 1) 7
(1,)
(0, 0) 2
(0, 1) 3
(1, 0) 8
(1, 1) 9
(2,)
(0, 0) 4
(0, 1) 5
(1, 0) 10
(1, 1) 11

nonzero(a)
Return the indices of the elements that are non-zero.

Returns a tuple of arrays, one for each dimension of `a`,

containing the indices of the non-zero elements in that
dimension. The values in `a` are always tested and returned in
row-major, C-style order.

To group the indices by element, rather than dimension, use `argwhere`,

which returns a row for each non-zero element.

.. note::

When called on a zero-d array or scalar, ``nonzero(a)`` is treated

as ``nonzero(atleast_1d(a))``.

.. deprecated:: 1.17.0

Use `atleast_1d` explicitly if this behavior is deliberate.

Parameters
----------
a : array_like
Input array.

Returns
-------
tuple_of_arrays : tuple
Indices of elements that are non-zero.

See Also
--------
flatnonzero :
Return indices that are non-zero in the flattened version of the input
array.
ndarray.nonzero :
Equivalent ndarray method.
count_nonzero :
Counts the number of non-zero elements in the input array.
 Notes
-----
While the nonzero values can be obtained with ``a[nonzero(a)]``, it is
recommended to use ``x[x.astype(bool)]`` or ``x[x != 0]`` instead, which
will correctly handle 0-d arrays.

Examples
--------
>>> x = np.array([[3, 0, 0], [0, 4, 0], [5, 6, 0]])
>>> x
array([[3, 0, 0],
[0, 4, 0],
[5, 6, 0]])
>>> np.nonzero(x)
(array([0, 1, 2, 2]), array([0, 1, 0, 1]))

>>> x[np.nonzero(x)]
array([3, 4, 5, 6])
>>> np.transpose(np.nonzero(x))
array([[0, 0],
[1, 1],
[2, 0],
[2, 1]])

A common use for ``nonzero`` is to find the indices of an array, where

a condition is True. Given an array `a`, the condition `a` > 3 is a
boolean array and since False is interpreted as 0, np.nonzero(a > 3)
yields the indices of the `a` where the condition is true.

>>> a = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

>>> a > 3
array([[False, False, False],
[ True, True, True],
[ True, True, True]])
>>> np.nonzero(a > 3)
(array([1, 1, 1, 2, 2, 2]), array([0, 1, 2, 0, 1, 2]))

Using this result to index `a` is equivalent to using the mask directly:

>>> a[np.nonzero(a > 3)]

array([4, 5, 6, 7, 8, 9])
>>> a[a > 3] # prefer this spelling
array([4, 5, 6, 7, 8, 9])

``nonzero`` can also be called as a method of the array.

>>> (a > 3).nonzero()

(array([1, 1, 1, 2, 2, 2]), array([0, 1, 2, 0, 1, 2]))

obj2sctype(rep, default=None)
Return the scalar dtype or NumPy equivalent of Python type of an object.

Parameters
----------
rep : any
The object of which the type is returned.
default : any, optional
If given, this is returned for objects whose types can not be
 determined. If not given, None is returned for those objects.

Returns
-------
dtype : dtype or Python type
The data type of `rep`.

See Also
--------
sctype2char, issctype, issubsctype, issubdtype, maximum_sctype

Examples
--------
>>> np.obj2sctype(np.int32)
<class 'numpy.int32'>
>>> np.obj2sctype(np.array([1., 2.]))
<class 'numpy.float64'>
>>> np.obj2sctype(np.array([1.j]))
<class 'numpy.complex128'>

>>> np.obj2sctype(dict)
<class 'numpy.object_'>
>>> np.obj2sctype('string')

>>> np.obj2sctype(1, default=list)

<class 'list'>

ones(shape, dtype=None, order='C', *, like=None)

Return a new array of given shape and type, filled with ones.

Parameters
----------
shape : int or sequence of ints
Shape of the new array, e.g., ``(2, 3)`` or ``2``.
dtype : data-type, optional
The desired data-type for the array, e.g., `numpy.int8`. Default is
`numpy.float64`.
order : {'C', 'F'}, optional, default: C
Whether to store multi-dimensional data in row-major
(C-style) or column-major (Fortran-style) order in
memory.
like : array_like, optional
Reference object to allow the creation of arrays which are not
NumPy arrays. If an array-like passed in as ``like`` supports
the ``__array_function__`` protocol, the result will be defined
by it. In this case, it ensures the creation of an array object
compatible with that passed in via this argument.

.. versionadded:: 1.20.0

Returns
-------
out : ndarray
Array of ones with the given shape, dtype, and order.

See Also
--------
ones_like : Return an array of ones with shape and type of input.
empty : Return a new uninitialized array.
 zeros : Return a new array setting values to zero.
full : Return a new array of given shape filled with value.

Examples
--------
>>> np.ones(5)
array([1., 1., 1., 1., 1.])

>>> np.ones((5,), dtype=int)

array([1, 1, 1, 1, 1])

>>> np.ones((2, 1))

array([[1.],
[1.]])

>>> s = (2,2)
>>> np.ones(s)
array([[1., 1.],
[1., 1.]])

ones_like(a, dtype=None, order='K', subok=True, shape=None)

Return an array of ones with the same shape and type as a given array.

Parameters
----------
a : array_like
The shape and data-type of `a` define these same attributes of
the returned array.
dtype : data-type, optional
Overrides the data type of the result.

.. versionadded:: 1.6.0
order : {'C', 'F', 'A', or 'K'}, optional
Overrides the memory layout of the result. '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.

.. versionadded:: 1.6.0
subok : bool, optional.
If True, then the newly created array will use the sub-class
type of `a`, otherwise it will be a base-class array. Defaults
to True.
shape : int or sequence of ints, optional.
Overrides the shape of the result. If order='K' and the number of
dimensions is unchanged, will try to keep order, otherwise,
order='C' is implied.

.. versionadded:: 1.17.0

Returns
-------
out : ndarray
Array of ones with the same shape and type as `a`.

See Also
--------
empty_like : Return an empty array with shape and type of input.
 zeros_like : Return an array of zeros with shape and type of input.
full_like : Return a new array with shape of input filled with value.
ones : Return a new array setting values to one.

Examples
--------
>>> x = np.arange(6)
>>> x = x.reshape((2, 3))
>>> x
array([[0, 1, 2],
[3, 4, 5]])
>>> np.ones_like(x)
array([[1, 1, 1],
[1, 1, 1]])

>>> y = np.arange(3, dtype=float)

>>> y
array([0., 1., 2.])
>>> np.ones_like(y)
array([1., 1., 1.])

outer(a, b, out=None)
Compute the outer product of two vectors.

Given two vectors `a` and `b` of length ``M`` and ``N``, repsectively,
the outer product [1]_ is::

[[a_0*b_0 a_0*b_1 ... a_0*b_{N-1} ]

[a_1*b_0 .
[ ... .
[a_{M-1}*b_0 a_{M-1}*b_{N-1} ]]

Parameters
----------
a : (M,) array_like
First input vector. Input is flattened if
not already 1-dimensional.
b : (N,) array_like
Second input vector. Input is flattened if
not already 1-dimensional.
out : (M, N) ndarray, optional
A location where the result is stored

.. versionadded:: 1.9.0

Returns
-------
out : (M, N) ndarray
``out[i, j] = a[i] * b[j]``

See also
--------
inner
einsum : ``einsum('i,j->ij', a.ravel(), b.ravel())`` is the equivalent.
ufunc.outer : A generalization to dimensions other than 1D and other
operations. ``np.multiply.outer(a.ravel(), b.ravel())``
is the equivalent.
tensordot : ``np.tensordot(a.ravel(), b.ravel(), axes=((), ()))``
is the equivalent.
 References
----------
.. [1] G. H. Golub and C. F. Van Loan, *Matrix Computations*, 3rd
ed., Baltimore, MD, Johns Hopkins University Press, 1996,
pg. 8.

Examples
--------
Make a (*very* coarse) grid for computing a Mandelbrot set:

>>> rl = np.outer(np.ones((5,)), np.linspace(-2, 2, 5))

>>> rl
array([[-2., -1., 0., 1., 2.],
[-2., -1., 0., 1., 2.],
[-2., -1., 0., 1., 2.],
[-2., -1., 0., 1., 2.],
[-2., -1., 0., 1., 2.]])
>>> im = np.outer(1j*np.linspace(2, -2, 5), np.ones((5,)))
>>> im
array([[0.+2.j, 0.+2.j, 0.+2.j, 0.+2.j, 0.+2.j],
[0.+1.j, 0.+1.j, 0.+1.j, 0.+1.j, 0.+1.j],
[0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j],
[0.-1.j, 0.-1.j, 0.-1.j, 0.-1.j, 0.-1.j],
[0.-2.j, 0.-2.j, 0.-2.j, 0.-2.j, 0.-2.j]])
>>> grid = rl + im
>>> grid
array([[-2.+2.j, -1.+2.j, 0.+2.j, 1.+2.j, 2.+2.j],
[-2.+1.j, -1.+1.j, 0.+1.j, 1.+1.j, 2.+1.j],
[-2.+0.j, -1.+0.j, 0.+0.j, 1.+0.j, 2.+0.j],
[-2.-1.j, -1.-1.j, 0.-1.j, 1.-1.j, 2.-1.j],
[-2.-2.j, -1.-2.j, 0.-2.j, 1.-2.j, 2.-2.j]])

An example using a "vector" of letters:

>>> x = np.array(['a', 'b', 'c'], dtype=object)

>>> np.outer(x, [1, 2, 3])
array([['a', 'aa', 'aaa'],
['b', 'bb', 'bbb'],
['c', 'cc', 'ccc']], dtype=object)

packbits(...)
packbits(a, /, axis=None, bitorder='big')

Packs the elements of a binary-valued array into bits in a uint8 array.

The result is padded to full bytes by inserting zero bits at the end.

Parameters
----------
a : array_like
An array of integers or booleans whose elements should be packed to
bits.
axis : int, optional
The dimension over which bit-packing is done.
``None`` implies packing the flattened array.
bitorder : {'big', 'little'}, optional
The order of the input bits. 'big' will mimic bin(val),
``[0, 0, 0, 0, 0, 0, 1, 1] => 3 = 0b00000011``, 'little' will
 reverse the order so ``[1, 1, 0, 0, 0, 0, 0, 0] => 3``.
Defaults to 'big'.

.. versionadded:: 1.17.0

Returns
-------
packed : ndarray
Array of type uint8 whose elements represent bits corresponding to the
logical (0 or nonzero) value of the input elements. The shape of
`packed` has the same number of dimensions as the input (unless `axis`
is None, in which case the output is 1-D).

See Also
--------
unpackbits: Unpacks elements of a uint8 array into a binary-valued output
array.

Examples
--------
>>> a = np.array([[[1,0,1],
... [0,1,0]],
... [[1,1,0],
... [0,0,1]]])
>>> b = np.packbits(a, axis=-1)
>>> b
array([[[160],
[ 64]],
[[192],
[ 32]]], dtype=uint8)

Note that in binary 160 = 1010 0000, 64 = 0100 0000, 192 = 1100 0000,
and 32 = 0010 0000.

pad(array, pad_width, mode='constant', **kwargs)

Pad an array.

Parameters
----------
array : array_like of rank N
The array to pad.
pad_width : {sequence, array_like, int}
Number of values padded to the edges of each axis.
``((before_1, after_1), ... (before_N, after_N))`` unique pad widths
for each axis.
``(before, after)`` or ``((before, after),)`` yields same before
and after pad for each axis.
``(pad,)`` or ``int`` is a shortcut for before = after = pad width
for all axes.
mode : str or function, optional
One of the following string values or a user supplied function.

'constant' (default)
Pads with a constant value.
'edge'
Pads with the edge values of array.
'linear_ramp'
Pads with the linear ramp between end_value and the
array edge value.
 'maximum'
Pads with the maximum value of all or part of the
vector along each axis.
'mean'
Pads with the mean value of all or part of the
vector along each axis.
'median'
Pads with the median value of all or part of the
vector along each axis.
'minimum'
Pads with the minimum value of all or part of the
vector along each axis.
'reflect'
Pads with the reflection of the vector mirrored on
the first and last values of the vector along each
axis.
'symmetric'
Pads with the reflection of the vector mirrored
along the edge of the array.
'wrap'
Pads with the wrap of the vector along the axis.
The first values are used to pad the end and the
end values are used to pad the beginning.
'empty'
Pads with undefined values.

.. versionadded:: 1.17

<function>
Padding function, see Notes.
stat_length : sequence or int, optional
Used in 'maximum', 'mean', 'median', and 'minimum'. Number of
values at edge of each axis used to calculate the statistic value.

``((before_1, after_1), ... (before_N, after_N))`` unique statistic

lengths for each axis.

``(before, after)`` or ``((before, after),)`` yields same before

and after statistic lengths for each axis.

``(stat_length,)`` or ``int`` is a shortcut for

``before = after = statistic`` length for all axes.

Default is ``None``, to use the entire axis.

constant_values : sequence or scalar, optional
Used in 'constant'. The values to set the padded values for each
axis.

``((before_1, after_1), ... (before_N, after_N))`` unique pad constants

for each axis.

``(before, after)`` or ``((before, after),)`` yields same before

and after constants for each axis.

``(constant,)`` or ``constant`` is a shortcut for

``before = after = constant`` for all axes.

Default is 0.
end_values : sequence or scalar, optional
 Used in 'linear_ramp'. The values used for the ending value of the
linear_ramp and that will form the edge of the padded array.

``((before_1, after_1), ... (before_N, after_N))`` unique end values

for each axis.

``(before, after)`` or ``((before, after),)`` yields same before

and after end values for each axis.

``(constant,)`` or ``constant`` is a shortcut for

``before = after = constant`` for all axes.

Default is 0.
reflect_type : {'even', 'odd'}, optional
Used in 'reflect', and 'symmetric'. The 'even' style is the
default with an unaltered reflection around the edge value. For
the 'odd' style, the extended part of the array is created by
subtracting the reflected values from two times the edge value.

Returns
-------
pad : ndarray
Padded array of rank equal to `array` with shape increased
according to `pad_width`.

Notes
-----
.. versionadded:: 1.7.0

For an array with rank greater than 1, some of the padding of later
axes is calculated from padding of previous axes. This is easiest to
think about with a rank 2 array where the corners of the padded array
are calculated by using padded values from the first axis.

The padding function, if used, should modify a rank 1 array in-place. It

has the following signature::

padding_func(vector, iaxis_pad_width, iaxis, kwargs)

where

vector : ndarray
A rank 1 array already padded with zeros. Padded values are
vector[:iaxis_pad_width[0]] and vector[-iaxis_pad_width[1]:].
iaxis_pad_width : tuple
A 2-tuple of ints, iaxis_pad_width[0] represents the number of
values padded at the beginning of vector where
iaxis_pad_width[1] represents the number of values padded at
the end of vector.
iaxis : int
The axis currently being calculated.
kwargs : dict
Any keyword arguments the function requires.

Examples
--------
>>> a = [1, 2, 3, 4, 5]
>>> np.pad(a, (2, 3), 'constant', constant_values=(4, 6))
array([4, 4, 1, ..., 6, 6, 6])
>>> np.pad(a, (2, 3), 'edge')
array([1, 1, 1, ..., 5, 5, 5])

>>> np.pad(a, (2, 3), 'linear_ramp', end_values=(5, -4))

array([ 5, 3, 1, 2, 3, 4, 5, 2, -1, -4])

>>> np.pad(a, (2,), 'maximum')

array([5, 5, 1, 2, 3, 4, 5, 5, 5])

>>> np.pad(a, (2,), 'mean')

array([3, 3, 1, 2, 3, 4, 5, 3, 3])

>>> np.pad(a, (2,), 'median')

array([3, 3, 1, 2, 3, 4, 5, 3, 3])

>>> a = [[1, 2], [3, 4]]

>>> np.pad(a, ((3, 2), (2, 3)), 'minimum')
array([[1, 1, 1, 2, 1, 1, 1],
[1, 1, 1, 2, 1, 1, 1],
[1, 1, 1, 2, 1, 1, 1],
[1, 1, 1, 2, 1, 1, 1],
[3, 3, 3, 4, 3, 3, 3],
[1, 1, 1, 2, 1, 1, 1],
[1, 1, 1, 2, 1, 1, 1]])

>>> a = [1, 2, 3, 4, 5]
>>> np.pad(a, (2, 3), 'reflect')
array([3, 2, 1, 2, 3, 4, 5, 4, 3, 2])

>>> np.pad(a, (2, 3), 'reflect', reflect_type='odd')

array([-1, 0, 1, 2, 3, 4, 5, 6, 7, 8])

>>> np.pad(a, (2, 3), 'symmetric')

array([2, 1, 1, 2, 3, 4, 5, 5, 4, 3])

>>> np.pad(a, (2, 3), 'symmetric', reflect_type='odd')

array([0, 1, 1, 2, 3, 4, 5, 5, 6, 7])

>>> np.pad(a, (2, 3), 'wrap')

array([4, 5, 1, 2, 3, 4, 5, 1, 2, 3])

>>> def pad_with(vector, pad_width, iaxis, kwargs):

... pad_value = kwargs.get('padder', 10)
... vector[:pad_width[0]] = pad_value
... vector[-pad_width[1]:] = pad_value
>>> a = np.arange(6)
>>> a = a.reshape((2, 3))
>>> np.pad(a, 2, pad_with)
array([[10, 10, 10, 10, 10, 10, 10],
[10, 10, 10, 10, 10, 10, 10],
[10, 10, 0, 1, 2, 10, 10],
[10, 10, 3, 4, 5, 10, 10],
[10, 10, 10, 10, 10, 10, 10],
[10, 10, 10, 10, 10, 10, 10]])
>>> np.pad(a, 2, pad_with, padder=100)
array([[100, 100, 100, 100, 100, 100, 100],
[100, 100, 100, 100, 100, 100, 100],
[100, 100, 0, 1, 2, 100, 100],
 [100, 100, 3, 4, 5, 100, 100],
[100, 100, 100, 100, 100, 100, 100],
[100, 100, 100, 100, 100, 100, 100]])

partition(a, kth, axis=-1, kind='introselect', order=None)

Return a partitioned copy of an array.

Creates a copy of the array with its elements rearranged in such a

way that the value of the element in k-th position is in the position
the value would be in a sorted array. In the partitioned array, all
elements before the k-th element are less than or equal to that
element, and all the elements after the k-th element are greater than
or equal to that element. The ordering of the elements in the two
partitions is undefined.

.. versionadded:: 1.8.0

Parameters
----------
a : array_like
Array to be sorted.
kth : int or sequence of ints
Element index to partition by. The k-th value of the element
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 k-th it will partition all elements
indexed by k-th of them into their sorted position at once.

.. deprecated:: 1.22.0
Passing booleans as index is deprecated.
axis : int or None, optional
Axis along which to sort. If None, the array is flattened before
sorting. The default is -1, which sorts 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. Not all fields need be
specified, but unspecified fields will still be used, in the
order in which they come up in the dtype, to break ties.

Returns
-------
partitioned_array : ndarray
Array of the same type and shape as `a`.

See Also
--------
ndarray.partition : Method to sort an array in-place.
argpartition : Indirect partition.
sort : Full sorting

Notes
-----
The various selection algorithms are characterized by their average
speed, worst case performance, work space size, and whether they are
stable. A stable sort keeps items with the same key in the same
 relative order. The available algorithms have the following
properties:

================= ======= ============= ============ =======

kind speed worst case work space stable
================= ======= ============= ============ =======
'introselect' 1 O(n) 0 no
================= ======= ============= ============ =======

All the partition algorithms make temporary copies of the data when
partitioning along any but the last axis. Consequently,
partitioning along the last axis is faster and uses less space than
partitioning along any other axis.

The sort order for complex numbers is lexicographic. If both the

real and imaginary parts are non-nan then the order is determined by
the real parts except when they are equal, in which case the order
is determined by the imaginary parts.

Examples
--------
>>> a = np.array([7, 1, 7, 7, 1, 5, 7, 2, 3, 2, 6, 2, 3, 0])
>>> p = np.partition(a, 4)
>>> p
array([0, 1, 2, 1, 2, 5, 2, 3, 3, 6, 7, 7, 7, 7])

``p[4]`` is 2; all elements in ``p[:4]`` are less than or equal

to ``p[4]``, and all elements in ``p[5:]`` are greater than or
equal to ``p[4]``. The partition is::

[0, 1, 2, 1], [2], [5, 2, 3, 3, 6, 7, 7, 7, 7]

The next example shows the use of multiple values passed to `kth`.

>>> p2 = np.partition(a, (4, 8))

>>> p2
array([0, 1, 2, 1, 2, 3, 3, 2, 5, 6, 7, 7, 7, 7])

``p2[4]`` is 2 and ``p2[8]`` is 5. All elements in ``p2[:4]``

are less than or equal to ``p2[4]``, all elements in ``p2[5:8]``
are greater than or equal to ``p2[4]`` and less than or equal to
``p2[8]``, and all elements in ``p2[9:]`` are greater than or
equal to ``p2[8]``. The partition is::

[0, 1, 2, 1], [2], [3, 3, 2], [5], [6, 7, 7, 7, 7]

percentile(a, q, axis=None, out=None, overwrite_input=False, method='linear',

keepdims=False, *, interpolation=None)
Compute the q-th percentile of the data along the specified axis.

Returns the q-th percentile(s) of the array elements.

Parameters
----------
a : array_like of real numbers
Input array or object that can be converted to an array.
q : array_like of float
Percentage or sequence of percentages for the percentiles to compute.
Values must be between 0 and 100 inclusive.
axis : {int, tuple of int, None}, optional
Axis or axes along which the percentiles are computed. The
default is to compute the percentile(s) along a flattened
version of the array.

.. versionchanged:: 1.9.0
A tuple of axes is supported
out : ndarray, optional
Alternative output array in which to place the result. It must
have the same shape and buffer length as the expected output,
but the type (of the output) will be cast if necessary.
overwrite_input : bool, optional
If True, then allow the input array `a` to be modified by intermediate
calculations, to save memory. In this case, the contents of the input
`a` after this function completes is undefined.
method : str, optional
This parameter specifies the method to use for estimating the
percentile. There are many different methods, some unique to NumPy.
See the notes for explanation. The options sorted by their R type
as summarized in the H&F paper [1]_ are:

1. 'inverted_cdf'
2. 'averaged_inverted_cdf'
3. 'closest_observation'
4. 'interpolated_inverted_cdf'
5. 'hazen'
6. 'weibull'
7. 'linear' (default)
8. 'median_unbiased'
9. 'normal_unbiased'

The first three methods are discontinuous. NumPy further defines the
following discontinuous variations of the default 'linear' (7.) option:

* 'lower'
* 'higher',
* 'midpoint'
* 'nearest'

.. versionchanged:: 1.22.0
This argument was previously called "interpolation" and only
offered the "linear" default and last four options.

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 array `a`.

.. versionadded:: 1.9.0

interpolation : str, optional

Deprecated name for the method keyword argument.

.. deprecated:: 1.22.0

Returns
-------
percentile : scalar or ndarray
If `q` is a single percentile and `axis=None`, then the result
 is a scalar. If multiple percentiles are given, first axis of
the result corresponds to the percentiles. The other axes are
the axes that remain after the reduction of `a`. If the input
contains integers or floats smaller than ``float64``, the output
data-type is ``float64``. Otherwise, the output data-type is the
same as that of the input. If `out` is specified, that array is
returned instead.

See Also
--------
mean
median : equivalent to ``percentile(..., 50)``
nanpercentile
quantile : equivalent to percentile, except q in the range [0, 1].

Notes
-----
Given a vector ``V`` of length ``n``, the q-th percentile of ``V`` is
the value ``q/100`` of the way from the minimum to the maximum in a
sorted copy of ``V``. The values and distances of the two nearest
neighbors as well as the `method` parameter will determine the
percentile if the normalized ranking does not match the location of
``q`` exactly. This function is the same as the median if ``q=50``, the
same as the minimum if ``q=0`` and the same as the maximum if
``q=100``.

The optional `method` parameter specifies the method to use when the
desired percentile lies between two indexes ``i`` and ``j = i + 1``.
In that case, we first determine ``i + g``, a virtual index that lies
between ``i`` and ``j``, where ``i`` is the floor and ``g`` is the
fractional part of the index. The final result is, then, an interpolation
of ``a[i]`` and ``a[j]`` based on ``g``. During the computation of ``g``,
``i`` and ``j`` are modified using correction constants ``alpha`` and
``beta`` whose choices depend on the ``method`` used. Finally, note that
since Python uses 0-based indexing, the code subtracts another 1 from the
index internally.

The following formula determines the virtual index ``i + g``, the location
of the percentile in the sorted sample:

.. math::
i + g = (q / 100) * ( n - alpha - beta + 1 ) + alpha

The different methods then work as follows

inverted_cdf:
method 1 of H&F [1]_.
This method gives discontinuous results:

* if g > 0 ; then take j

* if g = 0 ; then take i

averaged_inverted_cdf:
method 2 of H&F [1]_.
This method give discontinuous results:

* if g > 0 ; then take j

* if g = 0 ; then average between bounds
closest_observation:
method 3 of H&F [1]_.
This method give discontinuous results:

* if g > 0 ; then take j

* if g = 0 and index is odd ; then take j
* if g = 0 and index is even ; then take i

interpolated_inverted_cdf:
method 4 of H&F [1]_.
This method give continuous results using:

* alpha = 0
* beta = 1

hazen:
method 5 of H&F [1]_.
This method give continuous results using:

* alpha = 1/2
* beta = 1/2

weibull:
method 6 of H&F [1]_.
This method give continuous results using:

* alpha = 0
* beta = 0

linear:
method 7 of H&F [1]_.
This method give continuous results using:

* alpha = 1
* beta = 1

median_unbiased:
method 8 of H&F [1]_.
This method is probably the best method if the sample
distribution function is unknown (see reference).
This method give continuous results using:

* alpha = 1/3
* beta = 1/3

normal_unbiased:
method 9 of H&F [1]_.
This method is probably the best method if the sample
distribution function is known to be normal.
This method give continuous results using:

* alpha = 3/8
* beta = 3/8

lower:
NumPy method kept for backwards compatibility.
Takes ``i`` as the interpolation point.

higher:
 NumPy method kept for backwards compatibility.
Takes ``j`` as the interpolation point.

nearest:
NumPy method kept for backwards compatibility.
Takes ``i`` or ``j``, whichever is nearest.

midpoint:
NumPy method kept for backwards compatibility.
Uses ``(i + j) / 2``.

Examples
--------
>>> a = np.array([[10, 7, 4], [3, 2, 1]])
>>> a
array([[10, 7, 4],
[ 3, 2, 1]])
>>> np.percentile(a, 50)
3.5
>>> np.percentile(a, 50, axis=0)
array([6.5, 4.5, 2.5])
>>> np.percentile(a, 50, axis=1)
array([7., 2.])
>>> np.percentile(a, 50, axis=1, keepdims=True)
array([[7.],
[2.]])

>>> m = np.percentile(a, 50, axis=0)

>>> out = np.zeros_like(m)
>>> np.percentile(a, 50, axis=0, out=out)
array([6.5, 4.5, 2.5])
>>> m
array([6.5, 4.5, 2.5])

>>> b = a.copy()
>>> np.percentile(b, 50, axis=1, overwrite_input=True)
array([7., 2.])
>>> assert not np.all(a == b)

The different methods can be visualized graphically:

.. plot::

import matplotlib.pyplot as plt

a = np.arange(4)
p = np.linspace(0, 100, 6001)
ax = plt.gca()
lines = [
('linear', '-', 'C0'),
('inverted_cdf', ':', 'C1'),
# Almost the same as `inverted_cdf`:
('averaged_inverted_cdf', '-.', 'C1'),
('closest_observation', ':', 'C2'),
('interpolated_inverted_cdf', '--', 'C1'),
('hazen', '--', 'C3'),
('weibull', '-.', 'C4'),
('median_unbiased', '--', 'C5'),
('normal_unbiased', '-.', 'C6'),
 ]
for method, style, color in lines:
ax.plot(
p, np.percentile(a, p, method=method),
label=method, linestyle=style, color=color)
ax.set(
title='Percentiles for different methods and data: ' + str(a),
xlabel='Percentile',
ylabel='Estimated percentile value',
yticks=a)
ax.legend(bbox_to_anchor=(1.03, 1))
plt.tight_layout()
plt.show()

References
----------
.. [1] R. J. Hyndman and Y. Fan,
"Sample quantiles in statistical packages,"
The American Statistician, 50(4), pp. 361-365, 1996

piecewise(x, condlist, funclist, *args, **kw)

Evaluate a piecewise-defined function.

Given a set of conditions and corresponding functions, evaluate each

function on the input data wherever its condition is true.

Parameters
----------
x : ndarray or scalar
The input domain.
condlist : list of bool arrays or bool scalars
Each boolean array corresponds to a function in `funclist`. Wherever
`condlist[i]` is True, `funclist[i](x)` is used as the output value.

Each boolean array in `condlist` selects a piece of `x`,

and should therefore be of the same shape as `x`.

The length of `condlist` must correspond to that of `funclist`.

If one extra function is given, i.e. if
``len(funclist) == len(condlist) + 1``, then that extra function
is the default value, used wherever all conditions are false.
funclist : list of callables, f(x,*args,**kw), or scalars
Each function is evaluated over `x` wherever its corresponding
condition is True. It should take a 1d array as input and give an 1d
array or a scalar value as output. If, instead of a callable,
a scalar is provided then a constant function (``lambda x: scalar``) is
assumed.
args : tuple, optional
Any further arguments given to `piecewise` are passed to the functions
upon execution, i.e., if called ``piecewise(..., ..., 1, 'a')``, then
each function is called as ``f(x, 1, 'a')``.
kw : dict, optional
Keyword arguments used in calling `piecewise` are passed to the
functions upon execution, i.e., if called
``piecewise(..., ..., alpha=1)``, then each function is called as
``f(x, alpha=1)``.

Returns
-------
 out : ndarray
The output is the same shape and type as x and is found by
calling the functions in `funclist` on the appropriate portions of `x`,
as defined by the boolean arrays in `condlist`. Portions not covered
by any condition have a default value of 0.

See Also
--------
choose, select, where

Notes
-----
This is similar to choose or select, except that functions are
evaluated on elements of `x` that satisfy the corresponding condition from
`condlist`.

The result is::

|--
|funclist[0](x[condlist[0]])
out = |funclist[1](x[condlist[1]])
|...
|funclist[n2](x[condlist[n2]])
|--

Examples
--------
Define the sigma function, which is -1 for ``x < 0`` and +1 for ``x >= 0``.

>>> x = np.linspace(-2.5, 2.5, 6)

>>> np.piecewise(x, [x < 0, x >= 0], [-1, 1])
array([-1., -1., -1., 1., 1., 1.])

Define the absolute value, which is ``-x`` for ``x <0`` and ``x`` for
``x >= 0``.

>>> np.piecewise(x, [x < 0, x >= 0], [lambda x: -x, lambda x: x])

array([2.5, 1.5, 0.5, 0.5, 1.5, 2.5])

Apply the same function to a scalar value.

>>> y = -2
>>> np.piecewise(y, [y < 0, y >= 0], [lambda x: -x, lambda x: x])
array(2)

place(arr, mask, vals)

Change elements of an array based on conditional and input values.

Similar to ``np.copyto(arr, vals, where=mask)``, the difference is that

`place` uses the first N elements of `vals`, where N is the number of
True values in `mask`, while `copyto` uses the elements where `mask`
is True.

Note that `extract` does the exact opposite of `place`.

Parameters
----------
arr : ndarray
 Array to put data into.
mask : array_like
Boolean mask array. Must have the same size as `a`.
vals : 1-D sequence
Values to put into `a`. Only the first N elements are used, where
N is the number of True values in `mask`. If `vals` is smaller
than N, it will be repeated, and if elements of `a` are to be masked,
this sequence must be non-empty.

See Also
--------
copyto, put, take, extract

Examples
--------
>>> arr = np.arange(6).reshape(2, 3)
>>> np.place(arr, arr>2, [44, 55])
>>> arr
array([[ 0, 1, 2],
[44, 55, 44]])

poly(seq_of_zeros)
Find the coefficients of a polynomial with the given sequence of roots.

.. note::
This forms part of the old polynomial API. Since version 1.4, the
new polynomial API defined in `numpy.polynomial` is preferred.
A summary of the differences can be found in the
:doc:`transition guide </reference/routines.polynomials>`.

Returns the coefficients of the polynomial whose leading coefficient

is one for the given sequence of zeros (multiple roots must be included
in the sequence as many times as their multiplicity; see Examples).
A square matrix (or array, which will be treated as a matrix) can also
be given, in which case the coefficients of the characteristic polynomial
of the matrix are returned.

Parameters
----------
seq_of_zeros : array_like, shape (N,) or (N, N)
A sequence of polynomial roots, or a square array or matrix object.

Returns
-------
c : ndarray
1D array of polynomial coefficients from highest to lowest degree:

``c[0] * x**(N) + c[1] * x**(N-1) + ... + c[N-1] * x + c[N]``

where c[0] always equals 1.

Raises
------
ValueError
If input is the wrong shape (the input must be a 1-D or square
2-D array).

See Also
--------
polyval : Compute polynomial values.
 roots : Return the roots of a polynomial.
polyfit : Least squares polynomial fit.
poly1d : A one-dimensional polynomial class.

Notes
-----
Specifying the roots of a polynomial still leaves one degree of
freedom, typically represented by an undetermined leading
coefficient. [1]_ In the case of this function, that coefficient -
the first one in the returned array - is always taken as one. (If
for some reason you have one other point, the only automatic way
presently to leverage that information is to use ``polyfit``.)

The characteristic polynomial, :math:`p_a(t)`, of an `n`-by-`n`

matrix **A** is given by

:math:`p_a(t) = \mathrm{det}(t\, \mathbf{I} - \mathbf{A})`,

where **I** is the `n`-by-`n` identity matrix. [2]_

References
----------
.. [1] M. Sullivan and M. Sullivan, III, "Algebra and Trigonometry,
Enhanced With Graphing Utilities," Prentice-Hall, pg. 318, 1996.

.. [2] G. Strang, "Linear Algebra and Its Applications, 2nd Edition,"

Academic Press, pg. 182, 1980.

Examples
--------
Given a sequence of a polynomial's zeros:

>>> np.poly((0, 0, 0)) # Multiple root example

array([1., 0., 0., 0.])

The line above represents z**3 + 0*z**2 + 0*z + 0.

>>> np.poly((-1./2, 0, 1./2))

array([ 1. , 0. , -0.25, 0. ])

The line above represents z**3 - z/4

>>> np.poly((np.random.random(1)[0], 0, np.random.random(1)[0]))

array([ 1. , -0.77086955, 0.08618131, 0. ]) # random

Given a square array object:

>>> P = np.array([[0, 1./3], [-1./2, 0]])

>>> np.poly(P)
array([1. , 0. , 0.16666667])

Note how in all cases the leading coefficient is always 1.

polyadd(a1, a2)
Find the sum of two polynomials.

.. note::
This forms part of the old polynomial API. Since version 1.4, the
new polynomial API defined in `numpy.polynomial` is preferred.
 A summary of the differences can be found in the
:doc:`transition guide </reference/routines.polynomials>`.

Returns the polynomial resulting from the sum of two input polynomials.
Each input must be either a poly1d object or a 1D sequence of polynomial
coefficients, from highest to lowest degree.

Parameters
----------
a1, a2 : array_like or poly1d object
Input polynomials.

Returns
-------
out : ndarray or poly1d object
The sum of the inputs. If either input is a poly1d object, then the
output is also a poly1d object. Otherwise, it is a 1D array of
polynomial coefficients from highest to lowest degree.

See Also
--------
poly1d : A one-dimensional polynomial class.
poly, polyadd, polyder, polydiv, polyfit, polyint, polysub, polyval

Examples
--------
>>> np.polyadd([1, 2], [9, 5, 4])
array([9, 6, 6])

Using poly1d objects:

>>> p1 = np.poly1d([1, 2])

>>> p2 = np.poly1d([9, 5, 4])
>>> print(p1)
1 x + 2
>>> print(p2)
2
9 x + 5 x + 4
>>> print(np.polyadd(p1, p2))
2
9 x + 6 x + 6

polyder(p, m=1)
Return the derivative of the specified order of a polynomial.

.. note::
This forms part of the old polynomial API. Since version 1.4, the
new polynomial API defined in `numpy.polynomial` is preferred.
A summary of the differences can be found in the
:doc:`transition guide </reference/routines.polynomials>`.

Parameters
----------
p : poly1d or sequence
Polynomial to differentiate.
A sequence is interpreted as polynomial coefficients, see `poly1d`.
m : int, optional
Order of differentiation (default: 1)
 Returns
-------
der : poly1d
A new polynomial representing the derivative.

See Also
--------
polyint : Anti-derivative of a polynomial.
poly1d : Class for one-dimensional polynomials.

Examples
--------
The derivative of the polynomial :math:`x^3 + x^2 + x^1 + 1` is:

>>> p = np.poly1d([1,1,1,1])
>>> p2 = np.polyder(p)
>>> p2
poly1d([3, 2, 1])

which evaluates to:

>>> p2(2.)
17.0

We can verify this, approximating the derivative with

``(f(x + h) - f(x))/h``:

>>> (p(2. + 0.001) - p(2.)) / 0.001

17.007000999997857

The fourth-order derivative of a 3rd-order polynomial is zero:

>>> np.polyder(p, 2)
poly1d([6, 2])
>>> np.polyder(p, 3)
poly1d([6])
>>> np.polyder(p, 4)
poly1d([0])

polydiv(u, v)
Returns the quotient and remainder of polynomial division.

.. note::
This forms part of the old polynomial API. Since version 1.4, the
new polynomial API defined in `numpy.polynomial` is preferred.
A summary of the differences can be found in the
:doc:`transition guide </reference/routines.polynomials>`.

The input arrays are the coefficients (including any coefficients

equal to zero) of the "numerator" (dividend) and "denominator"
(divisor) polynomials, respectively.

Parameters
----------
u : array_like or poly1d
Dividend polynomial's coefficients.

v : array_like or poly1d
Divisor polynomial's coefficients.
 Returns
-------
q : ndarray
Coefficients, including those equal to zero, of the quotient.
r : ndarray
Coefficients, including those equal to zero, of the remainder.

See Also
--------
poly, polyadd, polyder, polydiv, polyfit, polyint, polymul, polysub
polyval

Notes
-----
Both `u` and `v` must be 0-d or 1-d (ndim = 0 or 1), but `u.ndim` need
not equal `v.ndim`. In other words, all four possible combinations -
``u.ndim = v.ndim = 0``, ``u.ndim = v.ndim = 1``,
``u.ndim = 1, v.ndim = 0``, and ``u.ndim = 0, v.ndim = 1`` - work.

Examples
--------
.. math:: \frac{3x^2 + 5x + 2}{2x + 1} = 1.5x + 1.75, remainder 0.25

>>> x = np.array([3.0, 5.0, 2.0])

>>> y = np.array([2.0, 1.0])
>>> np.polydiv(x, y)
(array([1.5 , 1.75]), array([0.25]))

polyfit(x, y, deg, rcond=None, full=False, w=None, cov=False)

Least squares polynomial fit.

.. note::
This forms part of the old polynomial API. Since version 1.4, the
new polynomial API defined in `numpy.polynomial` is preferred.
A summary of the differences can be found in the
:doc:`transition guide </reference/routines.polynomials>`.

Fit a polynomial ``p(x) = p[0] * x**deg + ... + p[deg]`` of degree `deg`

to points `(x, y)`. Returns a vector of coefficients `p` that minimises
the squared error in the order `deg`, `deg-1`, ... `0`.

The `Polynomial.fit <numpy.polynomial.polynomial.Polynomial.fit>` class

method is recommended for new code as it is more stable numerically. See
the documentation of the method for more information.

Parameters
----------
x : array_like, shape (M,)
x-coordinates of the M sample points ``(x[i], y[i])``.
y : array_like, shape (M,) or (M, K)
y-coordinates of the sample points. Several data sets of sample
points sharing the same x-coordinates can be fitted at once by
passing in a 2D-array that contains one dataset per column.
deg : int
Degree of the fitting polynomial
rcond : float, optional
Relative condition number of the fit. Singular values smaller than
this relative to the largest singular value will be ignored. The
 default value is len(x)*eps, where eps is the relative precision of
the float type, about 2e-16 in most cases.
full : bool, optional
Switch determining nature of return value. When it is False (the
default) just the coefficients are returned, when True diagnostic
information from the singular value decomposition is also returned.
w : array_like, shape (M,), optional
Weights. If not None, the weight ``w[i]`` applies to the unsquared
residual ``y[i] - y_hat[i]`` at ``x[i]``. Ideally the weights are
chosen so that the errors of the products ``w[i]*y[i]`` all have the
same variance. When using inverse-variance weighting, use
``w[i] = 1/sigma(y[i])``. The default value is None.
cov : bool or str, optional
If given and not `False`, return not just the estimate but also its
covariance matrix. By default, the covariance are scaled by
chi2/dof, where dof = M - (deg + 1), i.e., the weights are presumed
to be unreliable except in a relative sense and everything is scaled
such that the reduced chi2 is unity. This scaling is omitted if
``cov='unscaled'``, as is relevant for the case that the weights are
w = 1/sigma, with sigma known to be a reliable estimate of the
uncertainty.

Returns
-------
p : ndarray, shape (deg + 1,) or (deg + 1, K)
Polynomial coefficients, highest power first. If `y` was 2-D, the
coefficients for `k`-th data set are in ``p[:,k]``.

residuals, rank, singular_values, rcond

These values are only returned if ``full == True``

- residuals -- sum of squared residuals of the least squares fit

- rank -- the effective rank of the scaled Vandermonde
coefficient matrix
- singular_values -- singular values of the scaled Vandermonde
coefficient matrix
- rcond -- value of `rcond`.

For more details, see `numpy.linalg.lstsq`.

V : ndarray, shape (M,M) or (M,M,K)

Present only if ``full == False`` and ``cov == True``. The covariance
matrix of the polynomial coefficient estimates. The diagonal of
this matrix are the variance estimates for each coefficient. If y
is a 2-D array, then the covariance matrix for the `k`-th data set
are in ``V[:,:,k]``

Warns
-----
RankWarning
The rank of the coefficient matrix in the least-squares fit is
deficient. The warning is only raised if ``full == False``.

The warnings can be turned off by

>>> import warnings

>>> warnings.simplefilter('ignore', np.RankWarning)
See Also
--------
polyval : Compute polynomial values.
linalg.lstsq : Computes a least-squares fit.
scipy.interpolate.UnivariateSpline : Computes spline fits.

Notes
-----
The solution minimizes the squared error

.. math::
E = \sum_{j=0}^k |p(x_j) - y_j|^2

in the equations::

x[0]**n * p[0] + ... + x[0] * p[n-1] + p[n] = y[0]

x[1]**n * p[0] + ... + x[1] * p[n-1] + p[n] = y[1]
...
x[k]**n * p[0] + ... + x[k] * p[n-1] + p[n] = y[k]

The coefficient matrix of the coefficients `p` is a Vandermonde matrix.

`polyfit` issues a `RankWarning` when the least-squares fit is badly

conditioned. This implies that the best fit is not well-defined due
to numerical error. The results may be improved by lowering the polynomial
degree or by replacing `x` by `x` - `x`.mean(). The `rcond` parameter
can also be set to a value smaller than its default, but the resulting
fit may be spurious: including contributions from the small singular
values can add numerical noise to the result.

Note that fitting polynomial coefficients is inherently badly conditioned

when the degree of the polynomial is large or the interval of sample points
is badly centered. The quality of the fit should always be checked in these
cases. When polynomial fits are not satisfactory, splines may be a good
alternative.

References
----------
.. [1] Wikipedia, "Curve fitting",
https://en.wikipedia.org/wiki/Curve_fitting
.. [2] Wikipedia, "Polynomial interpolation",
https://en.wikipedia.org/wiki/Polynomial_interpolation

Examples
--------
>>> import warnings
>>> x = np.array([0.0, 1.0, 2.0, 3.0, 4.0, 5.0])
>>> y = np.array([0.0, 0.8, 0.9, 0.1, -0.8, -1.0])
>>> z = np.polyfit(x, y, 3)
>>> z
array([ 0.08703704, -0.81349206, 1.69312169, -0.03968254]) # may vary

It is convenient to use `poly1d` objects for dealing with polynomials:

>>> p = np.poly1d(z)
>>> p(0.5)
0.6143849206349179 # may vary
>>> p(3.5)
-0.34732142857143039 # may vary
 >>> p(10)
22.579365079365115 # may vary

High-order polynomials may oscillate wildly:

>>> with warnings.catch_warnings():

... warnings.simplefilter('ignore', np.RankWarning)
... p30 = np.poly1d(np.polyfit(x, y, 30))
...
>>> p30(4)
-0.80000000000000204 # may vary
>>> p30(5)
-0.99999999999999445 # may vary
>>> p30(4.5)
-0.10547061179440398 # may vary

Illustration:

>>> import matplotlib.pyplot as plt

>>> xp = np.linspace(-2, 6, 100)
>>> _ = plt.plot(x, y, '.', xp, p(xp), '-', xp, p30(xp), '--')
>>> plt.ylim(-2,2)
(-2, 2)
>>> plt.show()

polyint(p, m=1, k=None)

Return an antiderivative (indefinite integral) of a polynomial.

.. note::
This forms part of the old polynomial API. Since version 1.4, the
new polynomial API defined in `numpy.polynomial` is preferred.
A summary of the differences can be found in the
:doc:`transition guide </reference/routines.polynomials>`.

The returned order `m` antiderivative `P` of polynomial `p` satisfies

:math:`\frac{d^m}{dx^m}P(x) = p(x)` and is defined up to `m - 1`
integration constants `k`. The constants determine the low-order
polynomial part

.. math:: \frac{k_{m-1}}{0!} x^0 + \ldots + \frac{k_0}{(m-1)!}x^{m-1}

of `P` so that :math:`P^{(j)}(0) = k_{m-j-1}`.

Parameters
----------
p : array_like or poly1d
Polynomial to integrate.
A sequence is interpreted as polynomial coefficients, see `poly1d`.
m : int, optional
Order of the antiderivative. (Default: 1)
k : list of `m` scalars or scalar, optional
Integration constants. They are given in the order of integration:
those corresponding to highest-order terms come first.

If ``None`` (default), all constants are assumed to be zero.

If `m = 1`, a single scalar can be given instead of a list.

See Also
--------
 polyder : derivative of a polynomial
poly1d.integ : equivalent method

Examples
--------
The defining property of the antiderivative:

>>> p = np.poly1d([1,1,1])
>>> P = np.polyint(p)
>>> P
poly1d([ 0.33333333, 0.5 , 1. , 0. ]) # may vary
>>> np.polyder(P) == p
True

The integration constants default to zero, but can be specified:

>>> P = np.polyint(p, 3)
>>> P(0)
0.0
>>> np.polyder(P)(0)
0.0
>>> np.polyder(P, 2)(0)
0.0
>>> P = np.polyint(p, 3, k=[6,5,3])
>>> P
poly1d([ 0.01666667, 0.04166667, 0.16666667, 3. , 5. , 3. ]) # may
vary

Note that 3 = 6 / 2!, and that the constants are given in the order of
integrations. Constant of the highest-order polynomial term comes first:

>>> np.polyder(P, 2)(0)

6.0
>>> np.polyder(P, 1)(0)
5.0
>>> P(0)
3.0

polymul(a1, a2)
Find the product of two polynomials.

.. note::
This forms part of the old polynomial API. Since version 1.4, the
new polynomial API defined in `numpy.polynomial` is preferred.
A summary of the differences can be found in the
:doc:`transition guide </reference/routines.polynomials>`.

Finds the polynomial resulting from the multiplication of the two input
polynomials. Each input must be either a poly1d object or a 1D sequence
of polynomial coefficients, from highest to lowest degree.

Parameters
----------
a1, a2 : array_like or poly1d object
Input polynomials.

Returns
-------
out : ndarray or poly1d object
 The polynomial resulting from the multiplication of the inputs. If
either inputs is a poly1d object, then the output is also a poly1d
object. Otherwise, it is a 1D array of polynomial coefficients from
highest to lowest degree.

See Also
--------
poly1d : A one-dimensional polynomial class.
poly, polyadd, polyder, polydiv, polyfit, polyint, polysub, polyval
convolve : Array convolution. Same output as polymul, but has parameter
for overlap mode.

Examples
--------
>>> np.polymul([1, 2, 3], [9, 5, 1])
array([ 9, 23, 38, 17, 3])

Using poly1d objects:

>>> p1 = np.poly1d([1, 2, 3])

>>> p2 = np.poly1d([9, 5, 1])
>>> print(p1)
2
1 x + 2 x + 3
>>> print(p2)
2
9 x + 5 x + 1
>>> print(np.polymul(p1, p2))
4 3 2
9 x + 23 x + 38 x + 17 x + 3

polysub(a1, a2)
Difference (subtraction) of two polynomials.

.. note::
This forms part of the old polynomial API. Since version 1.4, the
new polynomial API defined in `numpy.polynomial` is preferred.
A summary of the differences can be found in the
:doc:`transition guide </reference/routines.polynomials>`.

Given two polynomials `a1` and `a2`, returns ``a1 - a2``.

`a1` and `a2` can be either array_like sequences of the polynomials'
coefficients (including coefficients equal to zero), or `poly1d` objects.

Parameters
----------
a1, a2 : array_like or poly1d
Minuend and subtrahend polynomials, respectively.

Returns
-------
out : ndarray or poly1d
Array or `poly1d` object of the difference polynomial's coefficients.

See Also
--------
polyval, polydiv, polymul, polyadd

Examples
 --------
.. math:: (2 x^2 + 10 x - 2) - (3 x^2 + 10 x -4) = (-x^2 + 2)

>>> np.polysub([2, 10, -2], [3, 10, -4])

array([-1, 0, 2])

polyval(p, x)
Evaluate a polynomial at specific values.

.. note::
This forms part of the old polynomial API. Since version 1.4, the
new polynomial API defined in `numpy.polynomial` is preferred.
A summary of the differences can be found in the
:doc:`transition guide </reference/routines.polynomials>`.

If `p` is of length N, this function returns the value:

``p[0]*x**(N-1) + p[1]*x**(N-2) + ... + p[N-2]*x + p[N-1]``

If `x` is a sequence, then ``p(x)`` is returned for each element of ``x``.

If `x` is another polynomial then the composite polynomial ``p(x(t))``
is returned.

Parameters
----------
p : array_like or poly1d object
1D array of polynomial coefficients (including coefficients equal
to zero) from highest degree to the constant term, or an
instance of poly1d.
x : array_like or poly1d object
A number, an array of numbers, or an instance of poly1d, at
which to evaluate `p`.

Returns
-------
values : ndarray or poly1d
If `x` is a poly1d instance, the result is the composition of the two
polynomials, i.e., `x` is "substituted" in `p` and the simplified
result is returned. In addition, the type of `x` - array_like or
poly1d - governs the type of the output: `x` array_like => `values`
array_like, `x` a poly1d object => `values` is also.

See Also
--------
poly1d: A polynomial class.

Notes
-----
Horner's scheme [1]_ is used to evaluate the polynomial. Even so,
for polynomials of high degree the values may be inaccurate due to
rounding errors. Use carefully.

If `x` is a subtype of `ndarray` the return value will be of the same type.

References
----------
.. [1] I. N. Bronshtein, K. A. Semendyayev, and K. A. Hirsch (Eng.
trans. Ed.), *Handbook of Mathematics*, New York, Van Nostrand
Reinhold Co., 1985, pg. 720.
 Examples
--------
>>> np.polyval([3,0,1], 5) # 3 * 5**2 + 0 * 5**1 + 1
76
>>> np.polyval([3,0,1], np.poly1d(5))
poly1d([76])
>>> np.polyval(np.poly1d([3,0,1]), 5)
76
>>> np.polyval(np.poly1d([3,0,1]), np.poly1d(5))
poly1d([76])

printoptions(*args, **kwargs)
Context manager for setting print options.

Set print options for the scope of the `with` block, and restore the old
options at the end. See `set_printoptions` for the full description of
available options.

Examples
--------

>>> from numpy.testing import assert_equal

>>> with np.printoptions(precision=2):
... np.array([2.0]) / 3
array([0.67])

The `as`-clause of the `with`-statement gives the current print options:

>>> with np.printoptions(precision=2) as opts:

... assert_equal(opts, np.get_printoptions())

See Also
--------
set_printoptions, get_printoptions

prod(a, axis=None, dtype=None, out=None, keepdims=<no value>, initial=<no

value>, where=<no value>)
Return the product of array elements over a given axis.

Parameters
----------
a : array_like
Input data.
axis : None or int or tuple of ints, optional
Axis or axes along which a product is performed. The default,
axis=None, will calculate the product of all the elements in the
input array. If axis is negative it counts from the last to the
first axis.

.. versionadded:: 1.7.0

If axis is a tuple of ints, a product is performed on all of the

axes specified in the tuple instead of a single axis or all the
axes as before.
dtype : dtype, optional
The type of the returned array, as well as of the accumulator in
which the elements are multiplied. The dtype of `a` is used by
default unless `a` has an integer dtype of less precision than the
 default platform integer. In that case, if `a` is signed then the
platform integer is used while if `a` is unsigned then an unsigned
integer of the same precision as the platform integer is used.
out : ndarray, optional
Alternative output array in which to place the result. It must have
the same shape as the expected output, but the type of the output
values will be cast if necessary.
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 input array.

If the default value is passed, then `keepdims` will not be

passed through to the `prod` method of sub-classes of
`ndarray`, however any non-default value will be. If the
sub-class' method does not implement `keepdims` any
exceptions will be raised.
initial : scalar, optional
The starting value for this product. See `~numpy.ufunc.reduce` for
details.

.. versionadded:: 1.15.0

where : array_like of bool, optional

Elements to include in the product. See `~numpy.ufunc.reduce` for
details.

.. versionadded:: 1.17.0

Returns
-------
product_along_axis : ndarray, see `dtype` parameter above.
An array shaped as `a` but with the specified axis removed.
Returns a reference to `out` if specified.

See Also
--------
ndarray.prod : equivalent method
:ref:`ufuncs-output-type`

Notes
-----
Arithmetic is modular when using integer types, and no error is
raised on overflow. That means that, on a 32-bit platform:

>>> x = np.array([536870910, 536870910, 536870910, 536870910])

>>> np.prod(x)
16 # may vary

The product of an empty array is the neutral element 1:

>>> np.prod([])
1.0

Examples
--------
By default, calculate the product of all elements:

>>> np.prod([1.,2.])
 2.0

Even when the input array is two-dimensional:

>>> a = np.array([[1., 2.], [3., 4.]])

>>> np.prod(a)
24.0

But we can also specify the axis over which to multiply:

>>> np.prod(a, axis=1)

array([ 2., 12.])
>>> np.prod(a, axis=0)
array([3., 8.])

Or select specific elements to include:

>>> np.prod([1., np.nan, 3.], where=[True, False, True])

3.0

If the type of `x` is unsigned, then the output type is

the unsigned platform integer:

>>> x = np.array([1, 2, 3], dtype=np.uint8)

>>> np.prod(x).dtype == np.uint
True

If `x` is of a signed integer type, then the output type

is the default platform integer:

>>> x = np.array([1, 2, 3], dtype=np.int8)

>>> np.prod(x).dtype == int
True

You can also start the product with a value other than one:

>>> np.prod([1, 2], initial=5)

10

product(*args, **kwargs)
Return the product of array elements over a given axis.

.. deprecated:: 1.25.0
``product`` is deprecated as of NumPy 1.25.0, and will be
removed in NumPy 2.0. Please use `prod` instead.

See Also
--------
prod : equivalent function; see for details.

promote_types(...)
promote_types(type1, type2)

Returns the data type with the smallest size and smallest scalar
kind to which both ``type1`` and ``type2`` may be safely cast.
The returned data type is always considered "canonical", this mainly
means that the promoted dtype will always be in native byte order.

This function is symmetric, but rarely associative.

 Parameters
----------
type1 : dtype or dtype specifier
First data type.
type2 : dtype or dtype specifier
Second data type.

Returns
-------
out : dtype
The promoted data type.

Notes
-----
Please see `numpy.result_type` for additional information about promotion.

.. versionadded:: 1.6.0

Starting in NumPy 1.9, promote_types function now returns a valid string

length when given an integer or float dtype as one argument and a string
dtype as another argument. Previously it always returned the input string
dtype, even if it wasn't long enough to store the max integer/float value
converted to a string.

.. versionchanged:: 1.23.0

NumPy now supports promotion for more structured dtypes. It will now
remove unnecessary padding from a structure dtype and promote included
fields individually.

See Also
--------
result_type, dtype, can_cast

Examples
--------
>>> np.promote_types('f4', 'f8')
dtype('float64')

>>> np.promote_types('i8', 'f4')

dtype('float64')

>>> np.promote_types('>i8', '<c8')

dtype('complex128')

>>> np.promote_types('i4', 'S8')

dtype('S11')

An example of a non-associative case:

>>> p = np.promote_types
>>> p('S', p('i1', 'u1'))
dtype('S6')
>>> p(p('S', 'i1'), 'u1')
dtype('S4')

ptp(a, axis=None, out=None, keepdims=<no value>)

Range of values (maximum - minimum) along an axis.
The name of the function comes from the acronym for 'peak to peak'.

.. warning::
`ptp` preserves the data type of the array. This means the
return value for an input of signed integers with n bits
(e.g. `np.int8`, `np.int16`, etc) is also a signed integer
with n bits. In that case, peak-to-peak values greater than
``2**(n-1)-1`` will be returned as negative values. An example
with a work-around is shown below.

Parameters
----------
a : array_like
Input values.
axis : None or int or tuple of ints, optional
Axis along which to find the peaks. By default, flatten the
array. `axis` may be negative, in
which case it counts from the last to the first axis.

.. versionadded:: 1.15.0

If this is a tuple of ints, a reduction is performed on multiple

axes, instead of a single axis or all the axes as before.
out : array_like
Alternative output array in which to place the result. It must
have the same shape and buffer length as the expected output,
but the type of the output values will be cast if necessary.

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 input array.

If the default value is passed, then `keepdims` will not be

passed through to the `ptp` method of sub-classes of
`ndarray`, however any non-default value will be. If the
sub-class' method does not implement `keepdims` any
exceptions will be raised.

Returns
-------
ptp : ndarray or scalar
The range of a given array - `scalar` if array is one-dimensional
or a new array holding the result along the given axis

Examples
--------
>>> x = np.array([[4, 9, 2, 10],
... [6, 9, 7, 12]])

>>> np.ptp(x, axis=1)

array([8, 6])

>>> np.ptp(x, axis=0)

array([2, 0, 5, 2])

>>> np.ptp(x)
10
 This example shows that a negative value can be returned when
the input is an array of signed integers.

>>> y = np.array([[1, 127],

... [0, 127],
... [-1, 127],
... [-2, 127]], dtype=np.int8)
>>> np.ptp(y, axis=1)
array([ 126, 127, -128, -127], dtype=int8)

A work-around is to use the `view()` method to view the result as

unsigned integers with the same bit width:

>>> np.ptp(y, axis=1).view(np.uint8)

array([126, 127, 128, 129], dtype=uint8)

put(a, ind, v, mode='raise')

Replaces specified elements of an array with given values.

The indexing works on the flattened target array. `put` is roughly

equivalent to:

::

a.flat[ind] = v

Parameters
----------
a : ndarray
Target array.
ind : array_like
Target indices, interpreted as integers.
v : array_like
Values to place in `a` at target indices. If `v` is shorter than
`ind` it will be repeated as necessary.
mode : {'raise', 'wrap', 'clip'}, optional
Specifies how out-of-bounds indices will behave.

* 'raise' -- raise an error (default)

* 'wrap' -- wrap around
* 'clip' -- clip to the range

'clip' mode means that all indices that are too large are replaced
by the index that addresses the last element along that axis. Note
that this disables indexing with negative numbers. In 'raise' mode,
if an exception occurs the target array may still be modified.

See Also
--------
putmask, place
put_along_axis : Put elements by matching the array and the index arrays

Examples
--------
>>> a = np.arange(5)
>>> np.put(a, [0, 2], [-44, -55])
>>> a
array([-44, 1, -55, 3, 4])
 >>> a = np.arange(5)
>>> np.put(a, 22, -5, mode='clip')
>>> a
array([ 0, 1, 2, 3, -5])

put_along_axis(arr, indices, values, axis)

Put values into the destination array by matching 1d index and data slices.

This iterates over matching 1d slices oriented along the specified axis in
the index and data arrays, and uses the former to place values into the
latter. These slices can be different lengths.

Functions returning an index along an axis, like `argsort` and

`argpartition`, produce suitable indices for this function.

.. versionadded:: 1.15.0

Parameters
----------
arr : ndarray (Ni..., M, Nk...)
Destination array.
indices : ndarray (Ni..., J, Nk...)
Indices to change along each 1d slice of `arr`. This must match the
dimension of arr, but dimensions in Ni and Nj may be 1 to broadcast
against `arr`.
values : array_like (Ni..., J, Nk...)
values to insert at those indices. Its shape and dimension are
broadcast to match that of `indices`.
axis : int
The axis to take 1d slices along. If axis is None, the destination
array is treated as if a flattened 1d view had been created of it.

Notes
-----
This is equivalent to (but faster than) the following use of `ndindex` and
`s_`, which sets each of ``ii`` and ``kk`` to a tuple of indices::

Ni, M, Nk = a.shape[:axis], a.shape[axis], a.shape[axis+1:]

J = indices.shape[axis] # Need not equal M

for ii in ndindex(Ni):
for kk in ndindex(Nk):
a_1d = a [ii + s_[:,] + kk]
indices_1d = indices[ii + s_[:,] + kk]
values_1d = values [ii + s_[:,] + kk]
for j in range(J):
a_1d[indices_1d[j]] = values_1d[j]

Equivalently, eliminating the inner loop, the last two lines would be::

a_1d[indices_1d] = values_1d

See Also
--------
take_along_axis :
Take values from the input array by matching 1d index and data slices

Examples
 --------

For this sample array

>>> a = np.array([[10, 30, 20], [60, 40, 50]])

We can replace the maximum values with:

>>> ai = np.argmax(a, axis=1, keepdims=True)

>>> ai
array([[1],
[0]])
>>> np.put_along_axis(a, ai, 99, axis=1)
>>> a
array([[10, 99, 20],
[99, 40, 50]])

putmask(...)
putmask(a, mask, values)

Changes elements of an array based on conditional and input values.

Sets ``a.flat[n] = values[n]`` for each n where ``mask.flat[n]==True``.

If `values` is not the same size as `a` and `mask` then it will repeat.
This gives behavior different from ``a[mask] = values``.

Parameters
----------
a : ndarray
Target array.
mask : array_like
Boolean mask array. It has to be the same shape as `a`.
values : array_like
Values to put into `a` where `mask` is True. If `values` is smaller
than `a` it will be repeated.

See Also
--------
place, put, take, copyto

Examples
--------
>>> x = np.arange(6).reshape(2, 3)
>>> np.putmask(x, x>2, x**2)
>>> x
array([[ 0, 1, 2],
[ 9, 16, 25]])

If `values` is smaller than `a` it is repeated:

>>> x = np.arange(5)
>>> np.putmask(x, x>1, [-33, -44])
>>> x
array([ 0, 1, -33, -44, -33])

quantile(a, q, axis=None, out=None, overwrite_input=False, method='linear',

keepdims=False, *, interpolation=None)
Compute the q-th quantile of the data along the specified axis.
.. versionadded:: 1.15.0

Parameters
----------
a : array_like of real numbers
Input array or object that can be converted to an array.
q : array_like of float
Probability or sequence of probabilities for the quantiles to compute.
Values must be between 0 and 1 inclusive.
axis : {int, tuple of int, None}, optional
Axis or axes along which the quantiles are computed. The default is
to compute the quantile(s) along a flattened version of the array.
out : ndarray, optional
Alternative output array in which to place the result. It must have
the same shape and buffer length as the expected output, but the
type (of the output) will be cast if necessary.
overwrite_input : bool, optional
If True, then allow the input array `a` to be modified by
intermediate calculations, to save memory. In this case, the
contents of the input `a` after this function completes is
undefined.
method : str, optional
This parameter specifies the method to use for estimating the
quantile. There are many different methods, some unique to NumPy.
See the notes for explanation. The options sorted by their R type
as summarized in the H&F paper [1]_ are:

1. 'inverted_cdf'
2. 'averaged_inverted_cdf'
3. 'closest_observation'
4. 'interpolated_inverted_cdf'
5. 'hazen'
6. 'weibull'
7. 'linear' (default)
8. 'median_unbiased'
9. 'normal_unbiased'

The first three methods are discontinuous. NumPy further defines the
following discontinuous variations of the default 'linear' (7.) option:

* 'lower'
* 'higher',
* 'midpoint'
* 'nearest'

.. versionchanged:: 1.22.0
This argument was previously called "interpolation" and only
offered the "linear" default and last four options.

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 array `a`.

interpolation : str, optional

Deprecated name for the method keyword argument.

.. deprecated:: 1.22.0
Returns
-------
quantile : scalar or ndarray
If `q` is a single probability and `axis=None`, then the result
is a scalar. If multiple probabilies levels are given, first axis of
the result corresponds to the quantiles. The other axes are
the axes that remain after the reduction of `a`. If the input
contains integers or floats smaller than ``float64``, the output
data-type is ``float64``. Otherwise, the output data-type is the
same as that of the input. If `out` is specified, that array is
returned instead.

See Also
--------
mean
percentile : equivalent to quantile, but with q in the range [0, 100].
median : equivalent to ``quantile(..., 0.5)``
nanquantile

Notes
-----
Given a vector ``V`` of length ``n``, the q-th quantile of ``V`` is
the value ``q`` of the way from the minimum to the maximum in a
sorted copy of ``V``. The values and distances of the two nearest
neighbors as well as the `method` parameter will determine the
quantile if the normalized ranking does not match the location of
``q`` exactly. This function is the same as the median if ``q=0.5``, the
same as the minimum if ``q=0.0`` and the same as the maximum if
``q=1.0``.

The optional `method` parameter specifies the method to use when the
desired quantile lies between two indexes ``i`` and ``j = i + 1``.
In that case, we first determine ``i + g``, a virtual index that lies
between ``i`` and ``j``, where ``i`` is the floor and ``g`` is the
fractional part of the index. The final result is, then, an interpolation
of ``a[i]`` and ``a[j]`` based on ``g``. During the computation of ``g``,
``i`` and ``j`` are modified using correction constants ``alpha`` and
``beta`` whose choices depend on the ``method`` used. Finally, note that
since Python uses 0-based indexing, the code subtracts another 1 from the
index internally.

The following formula determines the virtual index ``i + g``, the location
of the quantile in the sorted sample:

.. math::
i + g = q * ( n - alpha - beta + 1 ) + alpha

The different methods then work as follows

inverted_cdf:
method 1 of H&F [1]_.
This method gives discontinuous results:

* if g > 0 ; then take j

* if g = 0 ; then take i

averaged_inverted_cdf:
method 2 of H&F [1]_.
 This method gives discontinuous results:

* if g > 0 ; then take j

* if g = 0 ; then average between bounds

closest_observation:
method 3 of H&F [1]_.
This method gives discontinuous results:

* if g > 0 ; then take j

* if g = 0 and index is odd ; then take j
* if g = 0 and index is even ; then take i

interpolated_inverted_cdf:
method 4 of H&F [1]_.
This method gives continuous results using:

* alpha = 0
* beta = 1

hazen:
method 5 of H&F [1]_.
This method gives continuous results using:

* alpha = 1/2
* beta = 1/2

weibull:
method 6 of H&F [1]_.
This method gives continuous results using:

* alpha = 0
* beta = 0

linear:
method 7 of H&F [1]_.
This method gives continuous results using:

* alpha = 1
* beta = 1

median_unbiased:
method 8 of H&F [1]_.
This method is probably the best method if the sample
distribution function is unknown (see reference).
This method gives continuous results using:

* alpha = 1/3
* beta = 1/3

normal_unbiased:
method 9 of H&F [1]_.
This method is probably the best method if the sample
distribution function is known to be normal.
This method gives continuous results using:

* alpha = 3/8
* beta = 3/8
 lower:
NumPy method kept for backwards compatibility.
Takes ``i`` as the interpolation point.

higher:
NumPy method kept for backwards compatibility.
Takes ``j`` as the interpolation point.

nearest:
NumPy method kept for backwards compatibility.
Takes ``i`` or ``j``, whichever is nearest.

midpoint:
NumPy method kept for backwards compatibility.
Uses ``(i + j) / 2``.

Examples
--------
>>> a = np.array([[10, 7, 4], [3, 2, 1]])
>>> a
array([[10, 7, 4],
[ 3, 2, 1]])
>>> np.quantile(a, 0.5)
3.5
>>> np.quantile(a, 0.5, axis=0)
array([6.5, 4.5, 2.5])
>>> np.quantile(a, 0.5, axis=1)
array([7., 2.])
>>> np.quantile(a, 0.5, axis=1, keepdims=True)
array([[7.],
[2.]])
>>> m = np.quantile(a, 0.5, axis=0)
>>> out = np.zeros_like(m)
>>> np.quantile(a, 0.5, axis=0, out=out)
array([6.5, 4.5, 2.5])
>>> m
array([6.5, 4.5, 2.5])
>>> b = a.copy()
>>> np.quantile(b, 0.5, axis=1, overwrite_input=True)
array([7., 2.])
>>> assert not np.all(a == b)

See also `numpy.percentile` for a visualization of most methods.

References
----------
.. [1] R. J. Hyndman and Y. Fan,
"Sample quantiles in statistical packages,"
The American Statistician, 50(4), pp. 361-365, 1996

ravel(a, order='C')
Return a contiguous flattened array.

A 1-D array, containing the elements of the input, is returned. A copy is

made only if needed.

As of NumPy 1.10, the returned array will have the same type as the input
array. (for example, a masked array will be returned for a masked array
input)
Parameters
----------
a : array_like
Input array. The elements in `a` are read in the order specified by
`order`, and packed as a 1-D array.
order : {'C','F', 'A', 'K'}, optional

The elements of `a` are read using this index order. 'C' means
to index the elements in row-major, C-style order,
with the last axis index changing fastest, back to the first
axis index changing slowest. 'F' means to index the elements
in column-major, Fortran-style 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 `a` 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
-------
y : array_like
y is a contiguous 1-D array of the same subtype as `a`,
with shape ``(a.size,)``.
Note that matrices are special cased for backward compatibility,
if `a` is a matrix, then y is a 1-D ndarray.

See Also
--------
ndarray.flat : 1-D iterator over an array.
ndarray.flatten : 1-D array copy of the elements of an array
in row-major order.
ndarray.reshape : Change the shape of an array without changing its data.

Notes
-----
In row-major, C-style order, in two dimensions, the row index
varies the slowest, and the column index the quickest. This can
be generalized to multiple dimensions, where row-major order
implies that the index along the first axis varies slowest, and
the index along the last quickest. The opposite holds for
column-major, Fortran-style index ordering.

When a view is desired in as many cases as possible, ``arr.reshape(-1)``

may be preferable. However, ``ravel`` supports ``K`` in the optional
``order`` argument while ``reshape`` does not.

Examples
--------
It is equivalent to ``reshape(-1, order=order)``.

>>> x = np.array([[1, 2, 3], [4, 5, 6]])

>>> np.ravel(x)
array([1, 2, 3, 4, 5, 6])
 >>> x.reshape(-1)
array([1, 2, 3, 4, 5, 6])

>>> np.ravel(x, order='F')

array([1, 4, 2, 5, 3, 6])

When ``order`` is 'A', it will preserve the array's 'C' or 'F' ordering:

>>> np.ravel(x.T)
array([1, 4, 2, 5, 3, 6])
>>> np.ravel(x.T, order='A')
array([1, 2, 3, 4, 5, 6])

When ``order`` is 'K', it will preserve orderings that are neither 'C'
nor 'F', but won't reverse axes:

>>> a = np.arange(3)[::-1]; a
array([2, 1, 0])
>>> a.ravel(order='C')
array([2, 1, 0])
>>> a.ravel(order='K')
array([2, 1, 0])

>>> a = np.arange(12).reshape(2,3,2).swapaxes(1,2); a
array([[[ 0, 2, 4],
[ 1, 3, 5]],
[[ 6, 8, 10],
[ 7, 9, 11]]])
>>> a.ravel(order='C')
array([ 0, 2, 4, 1, 3, 5, 6, 8, 10, 7, 9, 11])
>>> a.ravel(order='K')
array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])

ravel_multi_index(...)
ravel_multi_index(multi_index, dims, mode='raise', order='C')

Converts a tuple of index arrays into an array of flat

indices, applying boundary modes to the multi-index.

Parameters
----------
multi_index : tuple of array_like
A tuple of integer arrays, one array for each dimension.
dims : tuple of ints
The shape of array into which the indices from ``multi_index`` apply.
mode : {'raise', 'wrap', 'clip'}, optional
Specifies how out-of-bounds indices are handled. Can specify
either one mode or a tuple of modes, one mode per index.

* 'raise' -- raise an error (default)

* 'wrap' -- wrap around
* 'clip' -- clip to the range

In 'clip' mode, a negative index which would normally

wrap will clip to 0 instead.
order : {'C', 'F'}, optional
Determines whether the multi-index should be viewed as
indexing in row-major (C-style) or column-major
(Fortran-style) order.
 Returns
-------
raveled_indices : ndarray
An array of indices into the flattened version of an array
of dimensions ``dims``.

See Also
--------
unravel_index

Notes
-----
.. versionadded:: 1.6.0

Examples
--------
>>> arr = np.array([[3,6,6],[4,5,1]])
>>> np.ravel_multi_index(arr, (7,6))
array([22, 41, 37])
>>> np.ravel_multi_index(arr, (7,6), order='F')
array([31, 41, 13])
>>> np.ravel_multi_index(arr, (4,6), mode='clip')
array([22, 23, 19])
>>> np.ravel_multi_index(arr, (4,4), mode=('clip','wrap'))
array([12, 13, 13])

>>> np.ravel_multi_index((3,1,4,1), (6,7,8,9))

1621

real(val)
Return the real part of the complex argument.

Parameters
----------
val : array_like
Input array.

Returns
-------
out : ndarray or scalar
The real component of the complex argument. If `val` is real, the type
of `val` is used for the output. If `val` has complex elements, the
returned type is float.

See Also
--------
real_if_close, imag, angle

Examples
--------
>>> a = np.array([1+2j, 3+4j, 5+6j])
>>> a.real
array([1., 3., 5.])
>>> a.real = 9
>>> a
array([9.+2.j, 9.+4.j, 9.+6.j])
>>> a.real = np.array([9, 8, 7])
>>> a
 array([9.+2.j, 8.+4.j, 7.+6.j])
>>> np.real(1 + 1j)
1.0

real_if_close(a, tol=100)
If input is complex with all imaginary parts close to zero, return
real parts.

"Close to zero" is defined as `tol` * (machine epsilon of the type for

`a`).

Parameters
----------
a : array_like
Input array.
tol : float
Tolerance in machine epsilons for the complex part of the elements
in the array. If the tolerance is <=1, then the absolute tolerance
is used.

Returns
-------
out : ndarray
If `a` is real, the type of `a` is used for the output. If `a`
has complex elements, the returned type is float.

See Also
--------
real, imag, angle

Notes
-----
Machine epsilon varies from machine to machine and between data types
but Python floats on most platforms have a machine epsilon equal to
2.2204460492503131e-16. You can use 'np.finfo(float).eps' to print
out the machine epsilon for floats.

Examples
--------
>>> np.finfo(float).eps
2.2204460492503131e-16 # may vary

>>> np.real_if_close([2.1 + 4e-14j, 5.2 + 3e-15j], tol=1000)

array([2.1, 5.2])
>>> np.real_if_close([2.1 + 4e-13j, 5.2 + 3e-15j], tol=1000)
array([2.1+4.e-13j, 5.2 + 3e-15j])

recfromcsv(fname, **kwargs)
Load ASCII data stored in a comma-separated file.

The returned array is a record array (if ``usemask=False``, see

`recarray`) or a masked record array (if ``usemask=True``,
see `ma.mrecords.MaskedRecords`).

Parameters
----------
fname, kwargs : For a description of input parameters, see `genfromtxt`.

See Also
 --------
numpy.genfromtxt : generic function to load ASCII data.

Notes
-----
By default, `dtype` is None, which means that the data-type of the output
array will be determined from the data.

recfromtxt(fname, **kwargs)
Load ASCII data from a file and return it in a record array.

If ``usemask=False`` a standard `recarray` is returned,

if ``usemask=True`` a MaskedRecords array is returned.

Parameters
----------
fname, kwargs : For a description of input parameters, see `genfromtxt`.

See Also
--------
numpy.genfromtxt : generic function

Notes
-----
By default, `dtype` is None, which means that the data-type of the output
array will be determined from the data.

repeat(a, repeats, axis=None)

Repeat each element of an array after themselves

Parameters
----------
a : array_like
Input array.
repeats : int or array of ints
The number of repetitions for each element. `repeats` is broadcasted
to fit the shape of the given axis.
axis : int, optional
The axis along which to repeat values. By default, use the
flattened input array, and return a flat output array.

Returns
-------
repeated_array : ndarray
Output array which has the same shape as `a`, except along
the given axis.

See Also
--------
tile : Tile an array.
unique : Find the unique elements of an array.

Examples
--------
>>> np.repeat(3, 4)
array([3, 3, 3, 3])
>>> x = np.array([[1,2],[3,4]])
>>> np.repeat(x, 2)
array([1, 1, 2, 2, 3, 3, 4, 4])
 >>> np.repeat(x, 3, axis=1)
array([[1, 1, 1, 2, 2, 2],
[3, 3, 3, 4, 4, 4]])
>>> np.repeat(x, [1, 2], axis=0)
array([[1, 2],
[3, 4],
[3, 4]])

require(a, dtype=None, requirements=None, *, like=None)

Return an ndarray of the provided type that satisfies requirements.

This function is useful to be sure that an array with the correct flags
is returned for passing to compiled code (perhaps through ctypes).

Parameters
----------
a : array_like
The object to be converted to a type-and-requirement-satisfying array.
dtype : data-type
The required data-type. If None preserve the current dtype. If your
application requires the data to be in native byteorder, include
a byteorder specification as a part of the dtype specification.
requirements : str or sequence of str
The requirements list can be any of the following

* 'F_CONTIGUOUS' ('F') - ensure a Fortran-contiguous array

* 'C_CONTIGUOUS' ('C') - ensure a C-contiguous array
* 'ALIGNED' ('A') - ensure a data-type aligned array
* 'WRITEABLE' ('W') - ensure a writable array
* 'OWNDATA' ('O') - ensure an array that owns its own data
* 'ENSUREARRAY', ('E') - ensure a base array, instead of a subclass
like : array_like, optional
Reference object to allow the creation of arrays which are not
NumPy arrays. If an array-like passed in as ``like`` supports
the ``__array_function__`` protocol, the result will be defined
by it. In this case, it ensures the creation of an array object
compatible with that passed in via this argument.

.. versionadded:: 1.20.0

Returns
-------
out : ndarray
Array with specified requirements and type if given.

See Also
--------
asarray : Convert input to an ndarray.
asanyarray : Convert to an ndarray, but pass through ndarray subclasses.
ascontiguousarray : Convert input to a contiguous array.
asfortranarray : Convert input to an ndarray with column-major
memory order.
ndarray.flags : Information about the memory layout of the array.

Notes
-----
The returned array will be guaranteed to have the listed requirements
by making a copy if needed.
 Examples
--------
>>> x = np.arange(6).reshape(2,3)
>>> x.flags
C_CONTIGUOUS : True
F_CONTIGUOUS : False
OWNDATA : False
WRITEABLE : True
ALIGNED : True
WRITEBACKIFCOPY : False

>>> y = np.require(x, dtype=np.float32, requirements=['A', 'O', 'W', 'F'])

>>> y.flags
C_CONTIGUOUS : False
F_CONTIGUOUS : True
OWNDATA : True
WRITEABLE : True
ALIGNED : True
WRITEBACKIFCOPY : False

reshape(a, newshape, order='C')

Gives a new shape to an array without changing its data.

Parameters
----------
a : array_like
Array to be reshaped.
newshape : int or tuple of ints
The new shape should be compatible with the original shape. If
an integer, then the result will be a 1-D array of that length.
One shape dimension can be -1. In this case, the value is
inferred from the length of the array and remaining dimensions.
order : {'C', 'F', 'A'}, optional
Read the elements of `a` using this index order, and place the
elements into the reshaped array using this index order. 'C'
means to read / write the elements using C-like index order,
with the last axis index changing fastest, back to the first
axis index changing slowest. 'F' means to read / write the
elements using 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 indexing.
'A' means to read / write the elements in Fortran-like index
order if `a` is Fortran *contiguous* in memory, C-like order
otherwise.

Returns
-------
reshaped_array : ndarray
This will be a new view object if possible; otherwise, it will
be a copy. Note there is no guarantee of the *memory layout* (C- or
Fortran- contiguous) of the returned array.

See Also
--------
ndarray.reshape : Equivalent method.

Notes
-----
 It is not always possible to change the shape of an array without copying
the data.

The `order` keyword gives the index ordering both for *fetching* the values
from `a`, and then *placing* the values into the output array.
For example, let's say you have an array:

>>> a = np.arange(6).reshape((3, 2))

>>> a
array([[0, 1],
[2, 3],
[4, 5]])

You can think of reshaping as first raveling the array (using the given
index order), then inserting the elements from the raveled array into the
new array using the same kind of index ordering as was used for the
raveling.

>>> np.reshape(a, (2, 3)) # C-like index ordering

array([[0, 1, 2],
[3, 4, 5]])
>>> np.reshape(np.ravel(a), (2, 3)) # equivalent to C ravel then C reshape
array([[0, 1, 2],
[3, 4, 5]])
>>> np.reshape(a, (2, 3), order='F') # Fortran-like index ordering
array([[0, 4, 3],
[2, 1, 5]])
>>> np.reshape(np.ravel(a, order='F'), (2, 3), order='F')
array([[0, 4, 3],
[2, 1, 5]])

Examples
--------
>>> a = np.array([[1,2,3], [4,5,6]])
>>> np.reshape(a, 6)
array([1, 2, 3, 4, 5, 6])
>>> np.reshape(a, 6, order='F')
array([1, 4, 2, 5, 3, 6])

>>> np.reshape(a, (3,-1)) # the unspecified value is inferred to be 2

array([[1, 2],
[3, 4],
[5, 6]])

resize(a, new_shape)
Return a new array with the specified shape.

If the new array is larger than the original array, then the new
array is filled with repeated copies of `a`. Note that this behavior
is different from a.resize(new_shape) which fills with zeros instead
of repeated copies of `a`.

Parameters
----------
a : array_like
Array to be resized.

new_shape : int or tuple of int

Shape of resized array.
 Returns
-------
reshaped_array : ndarray
The new array is formed from the data in the old array, repeated
if necessary to fill out the required number of elements. The
data are repeated iterating over the array in C-order.

See Also
--------
numpy.reshape : Reshape an array without changing the total size.
numpy.pad : Enlarge and pad an array.
numpy.repeat : Repeat elements of an array.
ndarray.resize : resize an array in-place.

Notes
-----
When the total size of the array does not change `~numpy.reshape` should
be used. In most other cases either indexing (to reduce the size)
or padding (to increase the size) may be a more appropriate solution.

Warning: This functionality does **not** consider axes separately,

i.e. it does not apply interpolation/extrapolation.
It fills the return array with the required number of elements, iterating
over `a` in C-order, disregarding axes (and cycling back from the start if
the new shape is larger). This functionality is therefore not suitable to
resize images, or data where each axis represents a separate and distinct
entity.

Examples
--------
>>> a=np.array([[0,1],[2,3]])
>>> np.resize(a,(2,3))
array([[0, 1, 2],
[3, 0, 1]])
>>> np.resize(a,(1,4))
array([[0, 1, 2, 3]])
>>> np.resize(a,(2,4))
array([[0, 1, 2, 3],
[0, 1, 2, 3]])

result_type(...)
result_type(*arrays_and_dtypes)

Returns the type that results from applying the NumPy

type promotion rules to the arguments.

Type promotion in NumPy works similarly to the rules in languages

like C++, with some slight differences. When both scalars and
arrays are used, the array's type takes precedence and the actual value
of the scalar is taken into account.

For example, calculating 3*a, where a is an array of 32-bit floats,

intuitively should result in a 32-bit float output. If the 3 is a
32-bit integer, the NumPy rules indicate it can't convert losslessly
into a 32-bit float, so a 64-bit float should be the result type.
By examining the value of the constant, '3', we see that it fits in
an 8-bit integer, which can be cast losslessly into the 32-bit float.
 Parameters
----------
arrays_and_dtypes : list of arrays and dtypes
The operands of some operation whose result type is needed.

Returns
-------
out : dtype
The result type.

See also
--------
dtype, promote_types, min_scalar_type, can_cast

Notes
-----
.. versionadded:: 1.6.0

The specific algorithm used is as follows.

Categories are determined by first checking which of boolean,

integer (int/uint), or floating point (float/complex) the maximum
kind of all the arrays and the scalars are.

If there are only scalars or the maximum category of the scalars

is higher than the maximum category of the arrays,
the data types are combined with :func:`promote_types`
to produce the return value.

Otherwise, `min_scalar_type` is called on each scalar, and

the resulting data types are all combined with :func:`promote_types`
to produce the return value.

The set of int values is not a subset of the uint values for types
with the same number of bits, something not reflected in
:func:`min_scalar_type`, but handled as a special case in `result_type`.

Examples
--------
>>> np.result_type(3, np.arange(7, dtype='i1'))
dtype('int8')

>>> np.result_type('i4', 'c8')

dtype('complex128')

>>> np.result_type(3.0, -2)

dtype('float64')

roll(a, shift, axis=None)

Roll array elements along a given axis.

Elements that roll beyond the last position are re-introduced at

the first.

Parameters
----------
a : array_like
Input array.
shift : int or tuple of ints
 The number of places by which elements are shifted. If a tuple,
then `axis` must be a tuple of the same size, and each of the
given axes is shifted by the corresponding number. If an int
while `axis` is a tuple of ints, then the same value is used for
all given axes.
axis : int or tuple of ints, optional
Axis or axes along which elements are shifted. By default, the
array is flattened before shifting, after which the original
shape is restored.

Returns
-------
res : ndarray
Output array, with the same shape as `a`.

See Also
--------
rollaxis : Roll the specified axis backwards, until it lies in a
given position.

Notes
-----
.. versionadded:: 1.12.0

Supports rolling over multiple dimensions simultaneously.

Examples
--------
>>> x = np.arange(10)
>>> np.roll(x, 2)
array([8, 9, 0, 1, 2, 3, 4, 5, 6, 7])
>>> np.roll(x, -2)
array([2, 3, 4, 5, 6, 7, 8, 9, 0, 1])

>>> x2 = np.reshape(x, (2, 5))

>>> x2
array([[0, 1, 2, 3, 4],
[5, 6, 7, 8, 9]])
>>> np.roll(x2, 1)
array([[9, 0, 1, 2, 3],
[4, 5, 6, 7, 8]])
>>> np.roll(x2, -1)
array([[1, 2, 3, 4, 5],
[6, 7, 8, 9, 0]])
>>> np.roll(x2, 1, axis=0)
array([[5, 6, 7, 8, 9],
[0, 1, 2, 3, 4]])
>>> np.roll(x2, -1, axis=0)
array([[5, 6, 7, 8, 9],
[0, 1, 2, 3, 4]])
>>> np.roll(x2, 1, axis=1)
array([[4, 0, 1, 2, 3],
[9, 5, 6, 7, 8]])
>>> np.roll(x2, -1, axis=1)
array([[1, 2, 3, 4, 0],
[6, 7, 8, 9, 5]])
>>> np.roll(x2, (1, 1), axis=(1, 0))
array([[9, 5, 6, 7, 8],
[4, 0, 1, 2, 3]])
 >>> np.roll(x2, (2, 1), axis=(1, 0))
array([[8, 9, 5, 6, 7],
[3, 4, 0, 1, 2]])

rollaxis(a, axis, start=0)

Roll the specified axis backwards, until it lies in a given position.

This function continues to be supported for backward compatibility, but you

should prefer `moveaxis`. The `moveaxis` function was added in NumPy
1.11.

Parameters
----------
a : ndarray
Input array.
axis : int
The axis to be rolled. The positions of the other axes do not
change relative to one another.
start : int, optional
When ``start <= axis``, the axis is rolled back until it lies in
this position. When ``start > axis``, the axis is rolled until it
lies before this position. The default, 0, results in a "complete"
roll. The following table describes how negative values of ``start``
are interpreted:

.. table::
:align: left

+-------------------+----------------------+
| ``start`` | Normalized ``start`` |
+===================+======================+
| ``-(arr.ndim+1)`` | raise ``AxisError`` |
+-------------------+----------------------+
| ``-arr.ndim`` | 0 |
+-------------------+----------------------+
| |vdots| | |vdots| |
+-------------------+----------------------+
| ``-1`` | ``arr.ndim-1`` |
+-------------------+----------------------+
| ``0`` | ``0`` |
+-------------------+----------------------+
| |vdots| | |vdots| |
+-------------------+----------------------+
| ``arr.ndim`` | ``arr.ndim`` |
+-------------------+----------------------+
| ``arr.ndim + 1`` | raise ``AxisError`` |
+-------------------+----------------------+

.. |vdots| unicode:: U+22EE .. Vertical Ellipsis

Returns
-------
res : ndarray
For NumPy >= 1.10.0 a view of `a` is always returned. For earlier
NumPy versions a view of `a` is returned only if the order of the
axes is changed, otherwise the input array is returned.

See Also
--------
 moveaxis : Move array axes to new positions.
roll : Roll the elements of an array by a number of positions along a
given axis.

Examples
--------
>>> a = np.ones((3,4,5,6))
>>> np.rollaxis(a, 3, 1).shape
(3, 6, 4, 5)
>>> np.rollaxis(a, 2).shape
(5, 3, 4, 6)
>>> np.rollaxis(a, 1, 4).shape
(3, 5, 6, 4)

roots(p)
Return the roots of a polynomial with coefficients given in p.

.. note::
This forms part of the old polynomial API. Since version 1.4, the
new polynomial API defined in `numpy.polynomial` is preferred.
A summary of the differences can be found in the
:doc:`transition guide </reference/routines.polynomials>`.

The values in the rank-1 array `p` are coefficients of a polynomial.

If the length of `p` is n+1 then the polynomial is described by::

p[0] * x**n + p[1] * x**(n-1) + ... + p[n-1]*x + p[n]

Parameters
----------
p : array_like
Rank-1 array of polynomial coefficients.

Returns
-------
out : ndarray
An array containing the roots of the polynomial.

Raises
------
ValueError
When `p` cannot be converted to a rank-1 array.

See also
--------
poly : Find the coefficients of a polynomial with a given sequence
of roots.
polyval : Compute polynomial values.
polyfit : Least squares polynomial fit.
poly1d : A one-dimensional polynomial class.

Notes
-----
The algorithm relies on computing the eigenvalues of the
companion matrix [1]_.

References
----------
.. [1] R. A. Horn & C. R. Johnson, *Matrix Analysis*. Cambridge, UK:
 Cambridge University Press, 1999, pp. 146-7.

Examples
--------
>>> coeff = [3.2, 2, 1]
>>> np.roots(coeff)
array([-0.3125+0.46351241j, -0.3125-0.46351241j])

rot90(m, k=1, axes=(0, 1))

Rotate an array by 90 degrees in the plane specified by axes.

Rotation direction is from the first towards the second axis.

This means for a 2D array with the default `k` and `axes`, the
rotation will be counterclockwise.

Parameters
----------
m : array_like
Array of two or more dimensions.
k : integer
Number of times the array is rotated by 90 degrees.
axes : (2,) array_like
The array is rotated in the plane defined by the axes.
Axes must be different.

.. versionadded:: 1.12.0

Returns
-------
y : ndarray
A rotated view of `m`.

See Also
--------
flip : Reverse the order of elements in an array along the given axis.
fliplr : Flip an array horizontally.
flipud : Flip an array vertically.

Notes
-----
``rot90(m, k=1, axes=(1,0))`` is the reverse of
``rot90(m, k=1, axes=(0,1))``

``rot90(m, k=1, axes=(1,0))`` is equivalent to

``rot90(m, k=-1, axes=(0,1))``

Examples
--------
>>> m = np.array([[1,2],[3,4]], int)
>>> m
array([[1, 2],
[3, 4]])
>>> np.rot90(m)
array([[2, 4],
[1, 3]])
>>> np.rot90(m, 2)
array([[4, 3],
[2, 1]])
>>> m = np.arange(8).reshape((2,2,2))
 >>> np.rot90(m, 1, (1,2))
array([[[1, 3],
[0, 2]],
[[5, 7],
[4, 6]]])

round_(a, decimals=0, out=None)

Round an array to the given number of decimals.

`~numpy.round_` is a disrecommended backwards-compatibility

alias of `~numpy.around` and `~numpy.round`.

.. deprecated:: 1.25.0
``round_`` is deprecated as of NumPy 1.25.0, and will be
removed in NumPy 2.0. Please use `round` instead.

See Also
--------
around : equivalent function; see for details.

row_stack = vstack(tup, *, dtype=None, casting='same_kind')

Stack arrays in sequence vertically (row wise).

This is equivalent to concatenation along the first axis after 1-D arrays
of shape `(N,)` have been reshaped to `(1,N)`. Rebuilds arrays divided by
`vsplit`.

This function makes most sense for arrays with up to 3 dimensions. For
instance, for pixel-data with a height (first axis), width (second axis),
and r/g/b channels (third axis). The functions `concatenate`, `stack` and
`block` provide more general stacking and concatenation operations.

``np.row_stack`` is an alias for `vstack`. They are the same function.

Parameters
----------
tup : sequence of ndarrays
The arrays must have the same shape along all but the first axis.
1-D arrays must have the same length.

dtype : str or dtype

If provided, the destination array will have this dtype. Cannot be
provided together with `out`.

.. versionadded:: 1.24

casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional

Controls what kind of data casting may occur. Defaults to 'same_kind'.

.. versionadded:: 1.24

Returns
-------
stacked : ndarray
The array formed by stacking the given arrays, will be at least 2-D.

See Also
--------
concatenate : Join a sequence of arrays along an existing axis.
 stack : Join a sequence of arrays along a new axis.
block : Assemble an nd-array from nested lists of blocks.
hstack : Stack arrays in sequence horizontally (column wise).
dstack : Stack arrays in sequence depth wise (along third axis).
column_stack : Stack 1-D arrays as columns into a 2-D array.
vsplit : Split an array into multiple sub-arrays vertically (row-wise).

Examples
--------
>>> a = np.array([1, 2, 3])
>>> b = np.array([4, 5, 6])
>>> np.vstack((a,b))
array([[1, 2, 3],
[4, 5, 6]])

>>> a = np.array([[1], [2], [3]])

>>> b = np.array([[4], [5], [6]])
>>> np.vstack((a,b))
array([[1],
[2],
[3],
[4],
[5],
[6]])

safe_eval(source)
Protected string evaluation.

Evaluate a string containing a Python literal expression without

allowing the execution of arbitrary non-literal code.

.. warning::

This function is identical to :py:meth:`ast.literal_eval` and

has the same security implications. It may not always be safe
to evaluate large input strings.

Parameters
----------
source : str
The string to evaluate.

Returns
-------
obj : object
The result of evaluating `source`.

Raises
------
SyntaxError
If the code has invalid Python syntax, or if it contains
non-literal code.

Examples
--------
>>> np.safe_eval('1')
1
>>> np.safe_eval('[1, 2, 3]')
[1, 2, 3]
 >>> np.safe_eval('{"foo": ("bar", 10.0)}')
{'foo': ('bar', 10.0)}

>>> np.safe_eval('import os')

Traceback (most recent call last):
...
SyntaxError: invalid syntax

>>> np.safe_eval('open("/home/user/.ssh/id_dsa").read()')
Traceback (most recent call last):
...
ValueError: malformed node or string: <_ast.Call object at 0x...>

save(file, arr, allow_pickle=True, fix_imports=True)

Save an array to a binary file in NumPy ``.npy`` format.

Parameters
----------
file : file, str, or pathlib.Path
File or filename to which the data is saved. If file is a file-object,
then the filename is unchanged. If file is a string or Path, a
``.npy``
extension will be appended to the filename if it does not already
have one.
arr : array_like
Array data to be saved.
allow_pickle : bool, optional
Allow saving object arrays using Python pickles. Reasons for
disallowing
pickles include security (loading pickled data can execute arbitrary
code) and portability (pickled objects may not be loadable on different
Python installations, for example if the stored objects require
libraries
that are not available, and not all pickled data is compatible between
Python 2 and Python 3).
Default: True
fix_imports : bool, optional
Only useful in forcing objects in object arrays on Python 3 to be
pickled in a Python 2 compatible way. If `fix_imports` is True, pickle
will try to map the new Python 3 names to the old module names used in
Python 2, so that the pickle data stream is readable with Python 2.

See Also
--------
savez : Save several arrays into a ``.npz`` archive
savetxt, load

Notes
-----
For a description of the ``.npy`` format, see :py:mod:`numpy.lib.format`.

Any data saved to the file is appended to the end of the file.

Examples
--------
>>> from tempfile import TemporaryFile
>>> outfile = TemporaryFile()

>>> x = np.arange(10)
 >>> np.save(outfile, x)

>>> _ = outfile.seek(0) # Only needed here to simulate closing & reopening

file
>>> np.load(outfile)
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

>>> with open('test.npy', 'wb') as f:

... np.save(f, np.array([1, 2]))
... np.save(f, np.array([1, 3]))
>>> with open('test.npy', 'rb') as f:
... a = np.load(f)
... b = np.load(f)
>>> print(a, b)
# [1 2] [1 3]

savetxt(fname, X, fmt='%.18e', delimiter=' ', newline='\n', header='',

footer='', comments='# ', encoding=None)
Save an array to a text file.

Parameters
----------
fname : filename or file handle
If the filename ends in ``.gz``, the file is automatically saved in
compressed gzip format. `loadtxt` understands gzipped files
transparently.
X : 1D or 2D array_like
Data to be saved to a text file.
fmt : str or sequence of strs, optional
A single format (%10.5f), a sequence of formats, or a
multi-format string, e.g. 'Iteration %d -- %10.5f', in which
case `delimiter` is ignored. For complex `X`, the legal options
for `fmt` are:

* a single specifier, `fmt='%.4e'`, resulting in numbers formatted

like `' (%s+%sj)' % (fmt, fmt)`
* a full string specifying every real and imaginary part, e.g.
`' %.4e %+.4ej %.4e %+.4ej %.4e %+.4ej'` for 3 columns
* a list of specifiers, one per column - in this case, the real
and imaginary part must have separate specifiers,
e.g. `['%.3e + %.3ej', '(%.15e%+.15ej)']` for 2 columns
delimiter : str, optional
String or character separating columns.
newline : str, optional
String or character separating lines.

.. versionadded:: 1.5.0
header : str, optional
String that will be written at the beginning of the file.

.. versionadded:: 1.7.0
footer : str, optional
String that will be written at the end of the file.

.. versionadded:: 1.7.0
comments : str, optional
String that will be prepended to the ``header`` and ``footer`` strings,
to mark them as comments. Default: '# ', as expected by e.g.
 ``numpy.loadtxt``.

.. versionadded:: 1.7.0
encoding : {None, str}, optional
Encoding used to encode the outputfile. Does not apply to output
streams. If the encoding is something other than 'bytes' or 'latin1'
you will not be able to load the file in NumPy versions < 1.14. Default
is 'latin1'.

.. versionadded:: 1.14.0

See Also
--------
save : Save an array to a binary file in NumPy ``.npy`` format
savez : Save several arrays into an uncompressed ``.npz`` archive
savez_compressed : Save several arrays into a compressed ``.npz`` archive

Notes
-----
Further explanation of the `fmt` parameter
(``%[flag]width[.precision]specifier``):

flags:
``-`` : left justify

``+`` : Forces to precede result with + or -.

``0`` : Left pad the number with zeros instead of space (see width).

width:
Minimum number of characters to be printed. The value is not truncated
if it has more characters.

precision:
- For integer specifiers (eg. ``d,i,o,x``), the minimum number of
digits.
- For ``e, E`` and ``f`` specifiers, the number of digits to print
after the decimal point.
- For ``g`` and ``G``, the maximum number of significant digits.
- For ``s``, the maximum number of characters.

specifiers:
``c`` : character

``d`` or ``i`` : signed decimal integer

``e`` or ``E`` : scientific notation with ``e`` or ``E``.

``f`` : decimal floating point

``g,G`` : use the shorter of ``e,E`` or ``f``

``o`` : signed octal

``s`` : string of characters

``u`` : unsigned decimal integer

 ``x,X`` : unsigned hexadecimal integer

This explanation of ``fmt`` is not complete, for an exhaustive

specification see [1]_.

References
----------
.. [1] `Format Specification Mini-Language
<https://docs.python.org/library/string.html#format-specification-
mini-language>`_,
Python Documentation.

Examples
--------
>>> x = y = z = np.arange(0.0,5.0,1.0)
>>> np.savetxt('test.out', x, delimiter=',') # X is an array
>>> np.savetxt('test.out', (x,y,z)) # x,y,z equal sized 1D arrays
>>> np.savetxt('test.out', x, fmt='%1.4e') # use exponential notation

savez(file, *args, **kwds)

Save several arrays into a single file in uncompressed ``.npz`` format.

Provide arrays as keyword arguments to store them under the

corresponding name in the output file: ``savez(fn, x=x, y=y)``.

If arrays are specified as positional arguments, i.e., ``savez(fn,

x, y)``, their names will be `arr_0`, `arr_1`, etc.

Parameters
----------
file : str or file
Either the filename (string) or an open file (file-like object)
where the data will be saved. If file is a string or a Path, the
``.npz`` extension will be appended to the filename if it is not
already there.
args : Arguments, optional
Arrays to save to the file. Please use keyword arguments (see
`kwds` below) to assign names to arrays. Arrays specified as
args will be named "arr_0", "arr_1", and so on.
kwds : Keyword arguments, optional
Arrays to save to the file. Each array will be saved to the
output file with its corresponding keyword name.

Returns
-------
None

See Also
--------
save : Save a single array to a binary file in NumPy format.
savetxt : Save an array to a file as plain text.
savez_compressed : Save several arrays into a compressed ``.npz`` archive

Notes
-----
The ``.npz`` file format is a zipped archive of files named after the
variables they contain. The archive is not compressed and each file
in the archive contains one variable in ``.npy`` format. For a
description of the ``.npy`` format, see :py:mod:`numpy.lib.format`.
 When opening the saved ``.npz`` file with `load` a `NpzFile` object is
returned. This is a dictionary-like object which can be queried for
its list of arrays (with the ``.files`` attribute), and for the arrays
themselves.

Keys passed in `kwds` are used as filenames inside the ZIP archive.
Therefore, keys should be valid filenames; e.g., avoid keys that begin with
``/`` or contain ``.``.

When naming variables with keyword arguments, it is not possible to name a

variable ``file``, as this would cause the ``file`` argument to be defined
twice in the call to ``savez``.

Examples
--------
>>> from tempfile import TemporaryFile
>>> outfile = TemporaryFile()
>>> x = np.arange(10)
>>> y = np.sin(x)

Using `savez` with \*args, the arrays are saved with default names.

>>> np.savez(outfile, x, y)
>>> _ = outfile.seek(0) # Only needed here to simulate closing & reopening
file
>>> npzfile = np.load(outfile)
>>> npzfile.files
['arr_0', 'arr_1']
>>> npzfile['arr_0']
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

Using `savez` with \**kwds, the arrays are saved with the keyword names.

>>> outfile = TemporaryFile()

>>> np.savez(outfile, x=x, y=y)
>>> _ = outfile.seek(0)
>>> npzfile = np.load(outfile)
>>> sorted(npzfile.files)
['x', 'y']
>>> npzfile['x']
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

savez_compressed(file, *args, **kwds)

Save several arrays into a single file in compressed ``.npz`` format.

Provide arrays as keyword arguments to store them under the

corresponding name in the output file: ``savez(fn, x=x, y=y)``.

If arrays are specified as positional arguments, i.e., ``savez(fn,

x, y)``, their names will be `arr_0`, `arr_1`, etc.

Parameters
----------
file : str or file
Either the filename (string) or an open file (file-like object)
where the data will be saved. If file is a string or a Path, the
``.npz`` extension will be appended to the filename if it is not
already there.
 args : Arguments, optional
Arrays to save to the file. Please use keyword arguments (see
`kwds` below) to assign names to arrays. Arrays specified as
args will be named "arr_0", "arr_1", and so on.
kwds : Keyword arguments, optional
Arrays to save to the file. Each array will be saved to the
output file with its corresponding keyword name.

Returns
-------
None

See Also
--------
numpy.save : Save a single array to a binary file in NumPy format.
numpy.savetxt : Save an array to a file as plain text.
numpy.savez : Save several arrays into an uncompressed ``.npz`` file format
numpy.load : Load the files created by savez_compressed.

Notes
-----
The ``.npz`` file format is a zipped archive of files named after the
variables they contain. The archive is compressed with
``zipfile.ZIP_DEFLATED`` and each file in the archive contains one variable
in ``.npy`` format. For a description of the ``.npy`` format, see
:py:mod:`numpy.lib.format`.

When opening the saved ``.npz`` file with `load` a `NpzFile` object is
returned. This is a dictionary-like object which can be queried for
its list of arrays (with the ``.files`` attribute), and for the arrays
themselves.

Examples
--------
>>> test_array = np.random.rand(3, 2)
>>> test_vector = np.random.rand(4)
>>> np.savez_compressed('/tmp/123', a=test_array, b=test_vector)
>>> loaded = np.load('/tmp/123.npz')
>>> print(np.array_equal(test_array, loaded['a']))
True
>>> print(np.array_equal(test_vector, loaded['b']))
True

sctype2char(sctype)
Return the string representation of a scalar dtype.

Parameters
----------
sctype : scalar dtype or object
If a scalar dtype, the corresponding string character is
returned. If an object, `sctype2char` tries to infer its scalar type
and then return the corresponding string character.

Returns
-------
typechar : str
The string character corresponding to the scalar type.
 Raises
------
ValueError
If `sctype` is an object for which the type can not be inferred.

See Also
--------
obj2sctype, issctype, issubsctype, mintypecode

Examples
--------
>>> for sctype in [np.int32, np.double, np.complex_, np.string_,
np.ndarray]:
... print(np.sctype2char(sctype))
l # may vary
d
D
S
O

>>> x = np.array([1., 2-1.j])

>>> np.sctype2char(x)
'D'
>>> np.sctype2char(list)
'O'

searchsorted(a, v, side='left', sorter=None)

Find indices where elements should be inserted to maintain order.

Find the indices into a sorted array `a` such that, if the
corresponding elements in `v` were inserted before the indices, the
order of `a` would be preserved.

Assuming that `a` is sorted:

====== ============================
`side` returned index `i` satisfies
====== ============================
left ``a[i-1] < v <= a[i]``
right ``a[i-1] <= v < a[i]``
====== ============================

Parameters
----------
a : 1-D array_like
Input array. If `sorter` is None, then it must be sorted in
ascending order, otherwise `sorter` must be an array of indices
that sort it.
v : array_like
Values to insert into `a`.
side : {'left', 'right'}, optional
If 'left', the index of the first suitable location found is given.
If 'right', return the last such index. If there is no suitable
index, return either 0 or N (where N is the length of `a`).
sorter : 1-D array_like, optional
Optional array of integer indices that sort array a into ascending
order. They are typically the result of argsort.

.. versionadded:: 1.7.0
 Returns
-------
indices : int or array of ints
Array of insertion points with the same shape as `v`,
or an integer if `v` is a scalar.

See Also
--------
sort : Return a sorted copy of an array.
histogram : Produce histogram from 1-D data.

Notes
-----
Binary search is used to find the required insertion points.

As of NumPy 1.4.0 `searchsorted` works with real/complex arrays containing

`nan` values. The enhanced sort order is documented in `sort`.

This function uses the same algorithm as the builtin python

`bisect.bisect_left`
(``side='left'``) and `bisect.bisect_right` (``side='right'``) functions,
which is also vectorized in the `v` argument.

Examples
--------
>>> np.searchsorted([1,2,3,4,5], 3)
2
>>> np.searchsorted([1,2,3,4,5], 3, side='right')
3
>>> np.searchsorted([1,2,3,4,5], [-10, 10, 2, 3])
array([0, 5, 1, 2])

select(condlist, choicelist, default=0)

Return an array drawn from elements in choicelist, depending on conditions.

Parameters
----------
condlist : list of bool ndarrays
The list of conditions which determine from which array in `choicelist`
the output elements are taken. When multiple conditions are satisfied,
the first one encountered in `condlist` is used.
choicelist : list of ndarrays
The list of arrays from which the output elements are taken. It has
to be of the same length as `condlist`.
default : scalar, optional
The element inserted in `output` when all conditions evaluate to False.

Returns
-------
output : ndarray
The output at position m is the m-th element of the array in
`choicelist` where the m-th element of the corresponding array in
`condlist` is True.

See Also
--------
where : Return elements from one of two arrays depending on condition.
take, choose, compress, diag, diagonal
 Examples
--------
>>> x = np.arange(6)
>>> condlist = [x<3, x>3]
>>> choicelist = [x, x**2]
>>> np.select(condlist, choicelist, 42)
array([ 0, 1, 2, 42, 16, 25])

>>> condlist = [x<=4, x>3]

>>> choicelist = [x, x**2]
>>> np.select(condlist, choicelist, 55)
array([ 0, 1, 2, 3, 4, 25])

set_numeric_ops(...)
set_numeric_ops(op1=func1, op2=func2, ...)

Set numerical operators for array objects.

.. deprecated:: 1.16

For the general case, use :c:func:`PyUFunc_ReplaceLoopBySignature`.

For ndarray subclasses, define the ``__array_ufunc__`` method and
override the relevant ufunc.

Parameters
----------
op1, op2, ... : callable
Each ``op = func`` pair describes an operator to be replaced.
For example, ``add = lambda x, y: np.add(x, y) % 5`` would replace
addition by modulus 5 addition.

Returns
-------
saved_ops : list of callables
A list of all operators, stored before making replacements.

Notes
-----
.. warning::
Use with care! Incorrect usage may lead to memory errors.

A function replacing an operator cannot make use of that operator.

For example, when replacing add, you may not use ``+``. Instead,
directly call ufuncs.

Examples
--------
>>> def add_mod5(x, y):
... return np.add(x, y) % 5
...
>>> old_funcs = np.set_numeric_ops(add=add_mod5)

>>> x = np.arange(12).reshape((3, 4))

>>> x + x
array([[0, 2, 4, 1],
[3, 0, 2, 4],
[1, 3, 0, 2]])
 >>> ignore = np.set_numeric_ops(**old_funcs) # restore operators

set_printoptions(precision=None, threshold=None, edgeitems=None,

linewidth=None, suppress=None, nanstr=None, infstr=None, formatter=None, sign=None,
floatmode=None, *, legacy=None)
Set printing options.

These options determine the way floating point numbers, arrays and
other NumPy objects are displayed.

Parameters
----------
precision : int or None, optional
Number of digits of precision for floating point output (default 8).
May be None if `floatmode` is not `fixed`, to print as many digits as
necessary to uniquely specify the value.
threshold : int, optional
Total number of array elements which trigger summarization
rather than full repr (default 1000).
To always use the full repr without summarization, pass `sys.maxsize`.
edgeitems : int, optional
Number of array items in summary at beginning and end of
each dimension (default 3).
linewidth : int, optional
The number of characters per line for the purpose of inserting
line breaks (default 75).
suppress : bool, optional
If True, always print floating point numbers using fixed point
notation, in which case numbers equal to zero in the current precision
will print as zero. If False, then scientific notation is used when
absolute value of the smallest number is < 1e-4 or the ratio of the
maximum absolute value to the minimum is > 1e3. The default is False.
nanstr : str, optional
String representation of floating point not-a-number (default nan).
infstr : str, optional
String representation of floating point infinity (default inf).
sign : string, either '-', '+', or ' ', optional
Controls printing of the sign of floating-point types. If '+', always
print the sign of positive values. If ' ', always prints a space
(whitespace character) in the sign position of positive values. If
'-', omit the sign character of positive values. (default '-')
formatter : dict of callables, optional
If not None, the keys should indicate the type(s) that the respective
formatting function applies to. Callables should return a string.
Types that are not specified (by their corresponding keys) are handled
by the default formatters. Individual types for which a formatter
can be set are:

- 'bool'
- 'int'
- 'timedelta' : a `numpy.timedelta64`
- 'datetime' : a `numpy.datetime64`
- 'float'
- 'longfloat' : 128-bit floats
- 'complexfloat'
- 'longcomplexfloat' : composed of two 128-bit floats
- 'numpystr' : types `numpy.bytes_` and `numpy.str_`
- 'object' : `np.object_` arrays
 Other keys that can be used to set a group of types at once are:

- 'all' : sets all types

- 'int_kind' : sets 'int'
- 'float_kind' : sets 'float' and 'longfloat'
- 'complex_kind' : sets 'complexfloat' and 'longcomplexfloat'
- 'str_kind' : sets 'numpystr'
floatmode : str, optional
Controls the interpretation of the `precision` option for
floating-point types. Can take the following values
(default maxprec_equal):

* 'fixed': Always print exactly `precision` fractional digits,

even if this would print more or fewer digits than
necessary to specify the value uniquely.
* 'unique': Print the minimum number of fractional digits necessary
to represent each value uniquely. Different elements may
have a different number of digits. The value of the
`precision` option is ignored.
* 'maxprec': Print at most `precision` fractional digits, but if
an element can be uniquely represented with fewer digits
only print it with that many.
* 'maxprec_equal': Print at most `precision` fractional digits,
but if every element in the array can be uniquely
represented with an equal number of fewer digits, use that
many digits for all elements.
legacy : string or `False`, optional
If set to the string `'1.13'` enables 1.13 legacy printing mode. This
approximates numpy 1.13 print output by including a space in the sign
position of floats and different behavior for 0d arrays. This also
enables 1.21 legacy printing mode (described below).

If set to the string `'1.21'` enables 1.21 legacy printing mode. This
approximates numpy 1.21 print output of complex structured dtypes
by not inserting spaces after commas that separate fields and after
colons.

If set to `False`, disables legacy mode.

Unrecognized strings will be ignored with a warning for forward

compatibility.

.. versionadded:: 1.14.0
.. versionchanged:: 1.22.0

See Also
--------
get_printoptions, printoptions, set_string_function, array2string

Notes
-----
`formatter` is always reset with a call to `set_printoptions`.

Use `printoptions` as a context manager to set the values temporarily.

Examples
--------
Floating point precision can be set:
 >>> np.set_printoptions(precision=4)
>>> np.array([1.123456789])
[1.1235]

Long arrays can be summarised:

>>> np.set_printoptions(threshold=5)
>>> np.arange(10)
array([0, 1, 2, ..., 7, 8, 9])

Small results can be suppressed:

>>> eps = np.finfo(float).eps

>>> x = np.arange(4.)
>>> x**2 - (x + eps)**2
array([-4.9304e-32, -4.4409e-16, 0.0000e+00, 0.0000e+00])
>>> np.set_printoptions(suppress=True)
>>> x**2 - (x + eps)**2
array([-0., -0., 0., 0.])

A custom formatter can be used to display array elements as desired:

>>> np.set_printoptions(formatter={'all':lambda x: 'int: '+str(-x)})

>>> x = np.arange(3)
>>> x
array([int: 0, int: -1, int: -2])
>>> np.set_printoptions() # formatter gets reset
>>> x
array([0, 1, 2])

To put back the default options, you can use:

>>> np.set_printoptions(edgeitems=3, infstr='inf',

... linewidth=75, nanstr='nan', precision=8,
... suppress=False, threshold=1000, formatter=None)

Also to temporarily override options, use `printoptions` as a context

manager:

>>> with np.printoptions(precision=2, suppress=True, threshold=5):

... np.linspace(0, 10, 10)
array([ 0. , 1.11, 2.22, ..., 7.78, 8.89, 10. ])

set_string_function(f, repr=True)
Set a Python function to be used when pretty printing arrays.

Parameters
----------
f : function or None
Function to be used to pretty print arrays. The function should expect
a single array argument and return a string of the representation of
the array. If None, the function is reset to the default NumPy function
to print arrays.
repr : bool, optional
If True (default), the function for pretty printing (``__repr__``)
is set, if False the function that returns the default string
representation (``__str__``) is set.

See Also
 --------
set_printoptions, get_printoptions

Examples
--------
>>> def pprint(arr):
... return 'HA! - What are you going to do now?'
...
>>> np.set_string_function(pprint)
>>> a = np.arange(10)
>>> a
HA! - What are you going to do now?
>>> _ = a
>>> # [0 1 2 3 4 5 6 7 8 9]

We can reset the function to the default:

>>> np.set_string_function(None)
>>> a
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

`repr` affects either pretty printing or normal string representation.

Note that ``__repr__`` is still affected by setting ``__str__``
because the width of each array element in the returned string becomes
equal to the length of the result of ``__str__()``.

>>> x = np.arange(4)
>>> np.set_string_function(lambda x:'random', repr=False)
>>> x.__str__()
'random'
>>> x.__repr__()
'array([0, 1, 2, 3])'

setbufsize(size)
Set the size of the buffer used in ufuncs.

Parameters
----------
size : int
Size of buffer.

setdiff1d(ar1, ar2, assume_unique=False)

Find the set difference of two arrays.

Return the unique values in `ar1` that are not in `ar2`.

Parameters
----------
ar1 : array_like
Input array.
ar2 : array_like
Input comparison array.
assume_unique : bool
If True, the input arrays are both assumed to be unique, which
can speed up the calculation. Default is False.

Returns
-------
setdiff1d : ndarray
 1D array of values in `ar1` that are not in `ar2`. The result
is sorted when `assume_unique=False`, but otherwise only sorted
if the input is sorted.

See Also
--------
numpy.lib.arraysetops : Module with a number of other functions for
performing set operations on arrays.

Examples
--------
>>> a = np.array([1, 2, 3, 2, 4, 1])
>>> b = np.array([3, 4, 5, 6])
>>> np.setdiff1d(a, b)
array([1, 2])

seterr(all=None, divide=None, over=None, under=None, invalid=None)

Set how floating-point errors are handled.

Note that operations on integer scalar types (such as `int16`) are

handled like floating point, and are affected by these settings.

Parameters
----------
all : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional
Set treatment for all types of floating-point errors at once:

- ignore: Take no action when the exception occurs.

- warn: Print a `RuntimeWarning` (via the Python `warnings` module).
- raise: Raise a `FloatingPointError`.
- call: Call a function specified using the `seterrcall` function.
- print: Print a warning directly to ``stdout``.
- log: Record error in a Log object specified by `seterrcall`.

The default is not to change the current behavior.

divide : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional
Treatment for division by zero.
over : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional
Treatment for floating-point overflow.
under : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional
Treatment for floating-point underflow.
invalid : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional
Treatment for invalid floating-point operation.

Returns
-------
old_settings : dict
Dictionary containing the old settings.

See also
--------
seterrcall : Set a callback function for the 'call' mode.
geterr, geterrcall, errstate

Notes
-----
The floating-point exceptions are defined in the IEEE 754 standard [1]_:

- Division by zero: infinite result obtained from finite numbers.

 - Overflow: result too large to be expressed.
- Underflow: result so close to zero that some precision
was lost.
- Invalid operation: result is not an expressible number, typically
indicates that a NaN was produced.

.. [1] https://en.wikipedia.org/wiki/IEEE_754

Examples
--------
>>> old_settings = np.seterr(all='ignore') #seterr to known value
>>> np.seterr(over='raise')
{'divide': 'ignore', 'over': 'ignore', 'under': 'ignore', 'invalid':
'ignore'}
>>> np.seterr(**old_settings) # reset to default
{'divide': 'ignore', 'over': 'raise', 'under': 'ignore', 'invalid':
'ignore'}

>>> np.int16(32000) * np.int16(3)

30464
>>> old_settings = np.seterr(all='warn', over='raise')
>>> np.int16(32000) * np.int16(3)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
FloatingPointError: overflow encountered in scalar multiply

>>> old_settings = np.seterr(all='print')

>>> np.geterr()
{'divide': 'print', 'over': 'print', 'under': 'print', 'invalid': 'print'}
>>> np.int16(32000) * np.int16(3)
30464

seterrcall(func)
Set the floating-point error callback function or log object.

There are two ways to capture floating-point error messages. The first
is to set the error-handler to 'call', using `seterr`. Then, set
the function to call using this function.

The second is to set the error-handler to 'log', using `seterr`.

Floating-point errors then trigger a call to the 'write' method of
the provided object.

Parameters
----------
func : callable f(err, flag) or object with write method
Function to call upon floating-point errors ('call'-mode) or
object whose 'write' method is used to log such message ('log'-mode).

The call function takes two arguments. The first is a string describing
the type of error (such as "divide by zero", "overflow", "underflow",
or "invalid value"), and the second is the status flag. The flag is a
byte, whose four least-significant bits indicate the type of error, one
of "divide", "over", "under", "invalid"::

[0 0 0 0 divide over under invalid]

In other words, ``flags = divide + 2*over + 4*under + 8*invalid``.

 If an object is provided, its write method should take one argument,
a string.

Returns
-------
h : callable, log instance or None
The old error handler.

See Also
--------
seterr, geterr, geterrcall

Examples
--------
Callback upon error:

>>> def err_handler(type, flag):

... print("Floating point error (%s), with flag %s" % (type, flag))
...

>>> saved_handler = np.seterrcall(err_handler)

>>> save_err = np.seterr(all='call')

>>> np.array([1, 2, 3]) / 0.0

Floating point error (divide by zero), with flag 1
array([inf, inf, inf])

>>> np.seterrcall(saved_handler)
<function err_handler at 0x...>
>>> np.seterr(**save_err)
{'divide': 'call', 'over': 'call', 'under': 'call', 'invalid': 'call'}

Log error message:

>>> class Log:

... def write(self, msg):
... print("LOG: %s" % msg)
...

>>> log = Log()

>>> saved_handler = np.seterrcall(log)
>>> save_err = np.seterr(all='log')

>>> np.array([1, 2, 3]) / 0.0

LOG: Warning: divide by zero encountered in divide
array([inf, inf, inf])

>>> np.seterrcall(saved_handler)
<numpy.core.numeric.Log object at 0x...>
>>> np.seterr(**save_err)
{'divide': 'log', 'over': 'log', 'under': 'log', 'invalid': 'log'}

seterrobj(...)
seterrobj(errobj, /)

Set the object that defines floating-point error handling.

The error object contains all information that defines the error handling
behavior in NumPy. `seterrobj` is used internally by the other
 functions that set error handling behavior (`seterr`, `seterrcall`).

Parameters
----------
errobj : list
The error object, a list containing three elements:
[internal numpy buffer size, error mask, error callback function].

The error mask is a single integer that holds the treatment information
on all four floating point errors. The information for each error type
is contained in three bits of the integer. If we print it in base 8, we
can see what treatment is set for "invalid", "under", "over", and
"divide" (in that order). The printed string can be interpreted with

* 0 : 'ignore'
* 1 : 'warn'
* 2 : 'raise'
* 3 : 'call'
* 4 : 'print'
* 5 : 'log'

See Also
--------
geterrobj, seterr, geterr, seterrcall, geterrcall
getbufsize, setbufsize

Notes
-----
For complete documentation of the types of floating-point exceptions and
treatment options, see `seterr`.

Examples
--------
>>> old_errobj = np.geterrobj() # first get the defaults
>>> old_errobj
[8192, 521, None]

>>> def err_handler(type, flag):

... print("Floating point error (%s), with flag %s" % (type, flag))
...
>>> new_errobj = [20000, 12, err_handler]
>>> np.seterrobj(new_errobj)
>>> np.base_repr(12, 8) # int for divide=4 ('print') and over=1 ('warn')
'14'
>>> np.geterr()
{'over': 'warn', 'divide': 'print', 'invalid': 'ignore', 'under': 'ignore'}
>>> np.geterrcall() is err_handler
True

setxor1d(ar1, ar2, assume_unique=False)

Find the set exclusive-or of two arrays.

Return the sorted, unique values that are in only one (not both) of the
input arrays.

Parameters
----------
ar1, ar2 : array_like
Input arrays.
 assume_unique : bool
If True, the input arrays are both assumed to be unique, which
can speed up the calculation. Default is False.

Returns
-------
setxor1d : ndarray
Sorted 1D array of unique values that are in only one of the input
arrays.

Examples
--------
>>> a = np.array([1, 2, 3, 2, 4])
>>> b = np.array([2, 3, 5, 7, 5])
>>> np.setxor1d(a,b)
array([1, 4, 5, 7])

shape(a)
Return the shape of an array.

Parameters
----------
a : array_like
Input array.

Returns
-------
shape : tuple of ints
The elements of the shape tuple give the lengths of the
corresponding array dimensions.

See Also
--------
len : ``len(a)`` is equivalent to ``np.shape(a)[0]`` for N-D arrays with
``N>=1``.
ndarray.shape : Equivalent array method.

Examples
--------
>>> np.shape(np.eye(3))
(3, 3)
>>> np.shape([[1, 3]])
(1, 2)
>>> np.shape([0])
(1,)
>>> np.shape(0)
()

>>> a = np.array([(1, 2), (3, 4), (5, 6)],

... dtype=[('x', 'i4'), ('y', 'i4')])
>>> np.shape(a)
(3,)
>>> a.shape
(3,)

shares_memory(...)
shares_memory(a, b, /, max_work=None)

Determine if two arrays share memory.

 .. warning::

This function can be exponentially slow for some inputs, unless

`max_work` is set to a finite number or ``MAY_SHARE_BOUNDS``.
If in doubt, use `numpy.may_share_memory` instead.

Parameters
----------
a, b : ndarray
Input arrays
max_work : int, optional
Effort to spend on solving the overlap problem (maximum number
of candidate solutions to consider). The following special
values are recognized:

max_work=MAY_SHARE_EXACT (default)
The problem is solved exactly. In this case, the function returns
True only if there is an element shared between the arrays. Finding
the exact solution may take extremely long in some cases.
max_work=MAY_SHARE_BOUNDS
Only the memory bounds of a and b are checked.

Raises
------
numpy.exceptions.TooHardError
Exceeded max_work.

Returns
-------
out : bool

See Also
--------
may_share_memory

Examples
--------
>>> x = np.array([1, 2, 3, 4])
>>> np.shares_memory(x, np.array([5, 6, 7]))
False
>>> np.shares_memory(x[::2], x)
True
>>> np.shares_memory(x[::2], x[1::2])
False

Checking whether two arrays share memory is NP-complete, and

runtime may increase exponentially in the number of
dimensions. Hence, `max_work` should generally be set to a finite
number, as it is possible to construct examples that take
extremely long to run:

>>> from numpy.lib.stride_tricks import as_strided

>>> x = np.zeros([192163377], dtype=np.int8)
>>> x1 = as_strided(x, strides=(36674, 61119, 85569), shape=(1049, 1049,
1049))
>>> x2 = as_strided(x[64023025:], strides=(12223, 12224, 1), shape=(1049,
1049, 1))
>>> np.shares_memory(x1, x2, max_work=1000)
 Traceback (most recent call last):
...
numpy.exceptions.TooHardError: Exceeded max_work

Running ``np.shares_memory(x1, x2)`` without `max_work` set takes

around 1 minute for this case. It is possible to find problems
that take still significantly longer.

show_config = show(mode='stdout')
Show libraries and system information on which NumPy was built
and is being used

Parameters
----------
mode : {`'stdout'`, `'dicts'`}, optional.
Indicates how to display the config information.
`'stdout'` prints to console, `'dicts'` returns a dictionary
of the configuration.

Returns
-------
out : {`dict`, `None`}
If mode is `'dicts'`, a dict is returned, else None

See Also
--------
get_include : Returns the directory containing NumPy C
header files.

Notes
-----
1. The `'stdout'` mode will give more readable
output if ``pyyaml`` is installed

show_runtime()
Print information about various resources in the system
including available intrinsic support and BLAS/LAPACK library
in use

.. versionadded:: 1.24.0

See Also
--------
show_config : Show libraries in the system on which NumPy was built.

Notes
-----
1. Information is derived with the help of `threadpoolctl
<https://pypi.org/project/threadpoolctl/>`_
library if available.
2. SIMD related information is derived from ``__cpu_features__``,
``__cpu_baseline__`` and ``__cpu_dispatch__``

sinc(x)
Return the normalized sinc function.

The sinc function is equal to :math:`\sin(\pi x)/(\pi x)` for any argument
:math:`x\ne 0`. ``sinc(0)`` takes the limit value 1, making ``sinc`` not
only everywhere continuous but also infinitely differentiable.
.. note::

Note the normalization factor of ``pi`` used in the definition.

This is the most commonly used definition in signal processing.
Use ``sinc(x / np.pi)`` to obtain the unnormalized sinc function
:math:`\sin(x)/x` that is more common in mathematics.

Parameters
----------
x : ndarray
Array (possibly multi-dimensional) of values for which to calculate
``sinc(x)``.

Returns
-------
out : ndarray
``sinc(x)``, which has the same shape as the input.

Notes
-----
The name sinc is short for "sine cardinal" or "sinus cardinalis".

The sinc function is used in various signal processing applications,

including in anti-aliasing, in the construction of a Lanczos resampling
filter, and in interpolation.

For bandlimited interpolation of discrete-time signals, the ideal

interpolation kernel is proportional to the sinc function.

References
----------
.. [1] Weisstein, Eric W. "Sinc Function." From MathWorld--A Wolfram Web
Resource. http://mathworld.wolfram.com/SincFunction.html
.. [2] Wikipedia, "Sinc function",
https://en.wikipedia.org/wiki/Sinc_function

Examples
--------
>>> import matplotlib.pyplot as plt
>>> x = np.linspace(-4, 4, 41)
>>> np.sinc(x)
array([-3.89804309e-17, -4.92362781e-02, -8.40918587e-02, # may vary
-8.90384387e-02, -5.84680802e-02, 3.89804309e-17,
6.68206631e-02, 1.16434881e-01, 1.26137788e-01,
8.50444803e-02, -3.89804309e-17, -1.03943254e-01,
-1.89206682e-01, -2.16236208e-01, -1.55914881e-01,
3.89804309e-17, 2.33872321e-01, 5.04551152e-01,
7.56826729e-01, 9.35489284e-01, 1.00000000e+00,
9.35489284e-01, 7.56826729e-01, 5.04551152e-01,
2.33872321e-01, 3.89804309e-17, -1.55914881e-01,
-2.16236208e-01, -1.89206682e-01, -1.03943254e-01,
-3.89804309e-17, 8.50444803e-02, 1.26137788e-01,
1.16434881e-01, 6.68206631e-02, 3.89804309e-17,
-5.84680802e-02, -8.90384387e-02, -8.40918587e-02,
-4.92362781e-02, -3.89804309e-17])

>>> plt.plot(x, np.sinc(x))

[<matplotlib.lines.Line2D object at 0x...>]
 >>> plt.title("Sinc Function")
Text(0.5, 1.0, 'Sinc Function')
>>> plt.ylabel("Amplitude")
Text(0, 0.5, 'Amplitude')
>>> plt.xlabel("X")
Text(0.5, 0, 'X')
>>> plt.show()

size(a, axis=None)
Return the number of elements along a given axis.

Parameters
----------
a : array_like
Input data.
axis : int, optional
Axis along which the elements are counted. By default, give
the total number of elements.

Returns
-------
element_count : int
Number of elements along the specified axis.

See Also
--------
shape : dimensions of array
ndarray.shape : dimensions of array
ndarray.size : number of elements in array

Examples
--------
>>> a = np.array([[1,2,3],[4,5,6]])
>>> np.size(a)
6
>>> np.size(a,1)
3
>>> np.size(a,0)
2

sometrue(*args, **kwargs)
Check whether some values are true.

Refer to `any` for full documentation.

.. deprecated:: 1.25.0
``sometrue`` is deprecated as of NumPy 1.25.0, and will be
removed in NumPy 2.0. Please use `any` instead.

See Also
--------
any : equivalent function; see for details.

sort(a, axis=-1, kind=None, order=None)

Return a sorted copy of an array.

Parameters
----------
a : array_like
 Array to be sorted.
axis : int or None, optional
Axis along which to sort. If None, the array is flattened before
sorting. The default is -1, which sorts along the last axis.
kind : {'quicksort', 'mergesort', 'heapsort', 'stable'}, optional
Sorting algorithm. The default is 'quicksort'. Note that both 'stable'
and 'mergesort' use timsort or radix sort under the covers and, in
general,
the actual implementation will vary with data type. 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.

Returns
-------
sorted_array : ndarray
Array of the same type and shape as `a`.

See Also
--------
ndarray.sort : Method to sort an array in-place.
argsort : Indirect sort.
lexsort : Indirect stable sort on multiple keys.
searchsorted : Find elements in a sorted array.
partition : Partial sort.

Notes
-----
The various sorting algorithms are characterized by their average speed,
worst case performance, work space size, and whether they are stable. A
stable sort keeps items with the same key in the same relative
order. The four algorithms implemented in NumPy have the following
properties:

=========== ======= ============= ============ ========

kind speed worst case work space stable
=========== ======= ============= ============ ========
'quicksort' 1 O(n^2) 0 no
'heapsort' 3 O(n*log(n)) 0 no
'mergesort' 2 O(n*log(n)) ~n/2 yes
'timsort' 2 O(n*log(n)) ~n/2 yes
=========== ======= ============= ============ ========

.. note:: The datatype determines which of 'mergesort' or 'timsort'

is actually used, even if 'mergesort' is specified. User selection
at a finer scale is not currently available.

All the sort algorithms make temporary copies of the data when
sorting along any but the last axis. Consequently, sorting along
the last axis is faster and uses less space than sorting along
 any other axis.

The sort order for complex numbers is lexicographic. If both the real
and imaginary parts are non-nan then the order is determined by the
real parts except when they are equal, in which case the order is
determined by the imaginary parts.

Previous to numpy 1.4.0 sorting real and complex arrays containing nan
values led to undefined behaviour. In numpy versions >= 1.4.0 nan
values are sorted to the end. The extended sort order is:

* Real: [R, nan]

* Complex: [R + Rj, R + nanj, nan + Rj, nan + nanj]

where R is a non-nan real value. Complex values with the same nan
placements are sorted according to the non-nan part if it exists.
Non-nan values are sorted as before.

.. versionadded:: 1.12.0

quicksort has been changed to `introsort

<https://en.wikipedia.org/wiki/Introsort>`_.
When sorting does not make enough progress it switches to
`heapsort <https://en.wikipedia.org/wiki/Heapsort>`_.
This implementation makes quicksort O(n*log(n)) in the worst case.

'stable' automatically chooses the best stable sorting algorithm

for the data type being sorted.
It, along with 'mergesort' is currently mapped to
`timsort <https://en.wikipedia.org/wiki/Timsort>`_
or `radix sort <https://en.wikipedia.org/wiki/Radix_sort>`_
depending on the data type.
API forward compatibility currently limits the
ability to select the implementation and it is hardwired for the different
data types.

.. versionadded:: 1.17.0

Timsort is added for better performance on already or nearly

sorted data. On random data timsort is almost identical to
mergesort. It is now used for stable sort while quicksort is still the
default sort if none is chosen. For timsort details, refer to
`CPython listsort.txt
<https://github.com/python/cpython/blob/3.7/Objects/listsort.txt>`_.
'mergesort' and 'stable' are mapped to radix sort for integer data types.
Radix sort is an
O(n) sort instead of O(n log n).

.. versionchanged:: 1.18.0

NaT now sorts to the end of arrays for consistency with NaN.

Examples
--------
>>> a = np.array([[1,4],[3,1]])
>>> np.sort(a) # sort along the last axis
array([[1, 4],
[1, 3]])
>>> np.sort(a, axis=None) # sort the flattened array
 array([1, 1, 3, 4])
>>> np.sort(a, axis=0) # sort along the first axis
array([[1, 1],
[3, 4]])

Use the `order` keyword to specify a field to use when sorting a

structured array:

>>> dtype = [('name', 'S10'), ('height', float), ('age', int)]

>>> values = [('Arthur', 1.8, 41), ('Lancelot', 1.9, 38),
... ('Galahad', 1.7, 38)]
>>> a = np.array(values, dtype=dtype) # create a structured array
>>> np.sort(a, order='height') # doctest: +SKIP
array([('Galahad', 1.7, 38), ('Arthur', 1.8, 41),
('Lancelot', 1.8999999999999999, 38)],
dtype=[('name', '|S10'), ('height', '<f8'), ('age', '<i4')])

Sort by age, then height if ages are equal:

>>> np.sort(a, order=['age', 'height']) # doctest: +SKIP

array([('Galahad', 1.7, 38), ('Lancelot', 1.8999999999999999, 38),
('Arthur', 1.8, 41)],
dtype=[('name', '|S10'), ('height', '<f8'), ('age', '<i4')])

sort_complex(a)
Sort a complex array using the real part first, then the imaginary part.

Parameters
----------
a : array_like
Input array

Returns
-------
out : complex ndarray
Always returns a sorted complex array.

Examples
--------
>>> np.sort_complex([5, 3, 6, 2, 1])
array([1.+0.j, 2.+0.j, 3.+0.j, 5.+0.j, 6.+0.j])

>>> np.sort_complex([1 + 2j, 2 - 1j, 3 - 2j, 3 - 3j, 3 + 5j])

array([1.+2.j, 2.-1.j, 3.-3.j, 3.-2.j, 3.+5.j])

source(object, output=<idlelib.run.StdOutputFile object at 0x0000019BD40A9300>)

Print or write to a file the source code for a NumPy object.

The source code is only returned for objects written in Python. Many
functions and classes are defined in C and will therefore not return
useful information.

Parameters
----------
object : numpy object
Input object. This can be any object (function, class, module,
...).
output : file object, optional
If `output` not supplied then source code is printed to screen
 (sys.stdout). File object must be created with either write 'w' or
append 'a' modes.

See Also
--------
lookfor, info

Examples
--------
>>> np.source(np.interp) #doctest: +SKIP
In file: /usr/lib/python2.6/dist-packages/numpy/lib/function_base.py
def interp(x, xp, fp, left=None, right=None):
""".... (full docstring printed)"""
if isinstance(x, (float, int, number)):
return compiled_interp([x], xp, fp, left, right).item()
else:
return compiled_interp(x, xp, fp, left, right)

The source code is only returned for objects written in Python.

>>> np.source(np.array) #doctest: +SKIP

Not available for this object.

split(ary, indices_or_sections, axis=0)

Split an array into multiple sub-arrays as views into `ary`.

Parameters
----------
ary : ndarray
Array to be divided into sub-arrays.
indices_or_sections : int or 1-D array
If `indices_or_sections` is an integer, N, the array will be divided
into N equal arrays along `axis`. If such a split is not possible,
an error is raised.

If `indices_or_sections` is a 1-D array of sorted integers, the entries

indicate where along `axis` the array is split. For example,
``[2, 3]`` would, for ``axis=0``, result in

- ary[:2]
- ary[2:3]
- ary[3:]

If an index exceeds the dimension of the array along `axis`,

an empty sub-array is returned correspondingly.
axis : int, optional
The axis along which to split, default is 0.

Returns
-------
sub-arrays : list of ndarrays
A list of sub-arrays as views into `ary`.

Raises
------
ValueError
If `indices_or_sections` is given as an integer, but
a split does not result in equal division.
 See Also
--------
array_split : Split an array into multiple sub-arrays of equal or
near-equal size. Does not raise an exception if
an equal division cannot be made.
hsplit : Split array into multiple sub-arrays horizontally (column-wise).
vsplit : Split array into multiple sub-arrays vertically (row wise).
dsplit : Split array into multiple sub-arrays along the 3rd axis (depth).
concatenate : Join a sequence of arrays along an existing axis.
stack : Join a sequence of arrays along a new axis.
hstack : Stack arrays in sequence horizontally (column wise).
vstack : Stack arrays in sequence vertically (row wise).
dstack : Stack arrays in sequence depth wise (along third dimension).

Examples
--------
>>> x = np.arange(9.0)
>>> np.split(x, 3)
[array([0., 1., 2.]), array([3., 4., 5.]), array([6., 7., 8.])]

>>> x = np.arange(8.0)
>>> np.split(x, [3, 5, 6, 10])
[array([0., 1., 2.]),
array([3., 4.]),
array([5.]),
array([6., 7.]),
array([], dtype=float64)]

squeeze(a, axis=None)
Remove axes of length one from `a`.

Parameters
----------
a : array_like
Input data.
axis : None or int or tuple of ints, optional
.. versionadded:: 1.7.0

Selects a subset of the entries of length one in the

shape. If an axis is selected with shape entry greater than
one, an error is raised.

Returns
-------
squeezed : ndarray
The input array, but with all or a subset of the
dimensions of length 1 removed. This is always `a` itself
or a view into `a`. Note that if all axes are squeezed,
the result is a 0d array and not a scalar.

Raises
------
ValueError
If `axis` is not None, and an axis being squeezed is not of length 1

See Also
--------
expand_dims : The inverse operation, adding entries of length one
reshape : Insert, remove, and combine dimensions, and resize existing ones
 Examples
--------
>>> x = np.array([[[0], [1], [2]]])
>>> x.shape
(1, 3, 1)
>>> np.squeeze(x).shape
(3,)
>>> np.squeeze(x, axis=0).shape
(3, 1)
>>> np.squeeze(x, axis=1).shape
Traceback (most recent call last):
...
ValueError: cannot select an axis to squeeze out which has size not equal
to one
>>> np.squeeze(x, axis=2).shape
(1, 3)
>>> x = np.array([[1234]])
>>> x.shape
(1, 1)
>>> np.squeeze(x)
array(1234) # 0d array
>>> np.squeeze(x).shape
()
>>> np.squeeze(x)[()]
1234

stack(arrays, axis=0, out=None, *, dtype=None, casting='same_kind')

Join a sequence of arrays along a new axis.

The ``axis`` parameter specifies the index of the new axis in the
dimensions of the result. For example, if ``axis=0`` it will be the first
dimension and if ``axis=-1`` it will be the last dimension.

.. versionadded:: 1.10.0

Parameters
----------
arrays : sequence of array_like
Each array must have the same shape.

axis : int, optional

The axis in the result array along which the input arrays are stacked.

out : ndarray, optional

If provided, the destination to place the result. The shape must be
correct, matching that of what stack would have returned if no
out argument were specified.

dtype : str or dtype

If provided, the destination array will have this dtype. Cannot be
provided together with `out`.

.. versionadded:: 1.24

casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional

Controls what kind of data casting may occur. Defaults to 'same_kind'.

.. versionadded:: 1.24
 Returns
-------
stacked : ndarray
The stacked array has one more dimension than the input arrays.

See Also
--------
concatenate : Join a sequence of arrays along an existing axis.
block : Assemble an nd-array from nested lists of blocks.
split : Split array into a list of multiple sub-arrays of equal size.

Examples
--------
>>> arrays = [np.random.randn(3, 4) for _ in range(10)]
>>> np.stack(arrays, axis=0).shape
(10, 3, 4)

>>> np.stack(arrays, axis=1).shape

(3, 10, 4)

>>> np.stack(arrays, axis=2).shape

(3, 4, 10)

>>> a = np.array([1, 2, 3])

>>> b = np.array([4, 5, 6])
>>> np.stack((a, b))
array([[1, 2, 3],
[4, 5, 6]])

>>> np.stack((a, b), axis=-1)

array([[1, 4],
[2, 5],
[3, 6]])

std(a, axis=None, dtype=None, out=None, ddof=0, keepdims=<no value>, *,

where=<no value>)
Compute the standard deviation along the specified axis.

Returns the standard deviation, a measure of the spread of a distribution,

of the array elements. The standard deviation is computed for the
flattened array by default, otherwise over the specified axis.

Parameters
----------
a : array_like
Calculate the standard deviation of these values.
axis : None or int or tuple of ints, optional
Axis or axes along which the standard deviation is computed. The
default is to compute the standard deviation of the flattened array.

.. versionadded:: 1.7.0

If this is a tuple of ints, a standard deviation is performed over

multiple axes, instead of a single axis or all the axes as before.
dtype : dtype, optional
Type to use in computing the standard deviation. For arrays of
integer type the default is float64, for arrays of float types it is
 the same as the array type.
out : ndarray, optional
Alternative output array in which to place the result. It must have
the same shape as the expected output but the type (of the calculated
values) will be cast if necessary.
ddof : int, optional
Means Delta Degrees of Freedom. The divisor used in calculations
is ``N - ddof``, where ``N`` represents the number of elements.
By default `ddof` is zero.
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 input array.

If the default value is passed, then `keepdims` will not be

passed through to the `std` method of sub-classes of
`ndarray`, however any non-default value will be. If the
sub-class' method does not implement `keepdims` any
exceptions will be raised.

where : array_like of bool, optional

Elements to include in the standard deviation.
See `~numpy.ufunc.reduce` for details.

.. versionadded:: 1.20.0

Returns
-------
standard_deviation : ndarray, see dtype parameter above.
If `out` is None, return a new array containing the standard deviation,
otherwise return a reference to the output array.

See Also
--------
var, mean, nanmean, nanstd, nanvar
:ref:`ufuncs-output-type`

Notes
-----
The standard deviation is the square root of the average of the squared
deviations from the mean, i.e., ``std = sqrt(mean(x))``, where
``x = abs(a - a.mean())**2``.

The average squared deviation is typically calculated as ``x.sum() / N``,

where ``N = len(x)``. If, however, `ddof` is specified, the divisor
``N - ddof`` is used instead. In standard statistical practice, ``ddof=1``
provides an unbiased estimator of the variance of the infinite population.
``ddof=0`` provides a maximum likelihood estimate of the variance for
normally distributed variables. The standard deviation computed in this
function is the square root of the estimated variance, so even with
``ddof=1``, it will not be an unbiased estimate of the standard deviation
per se.

Note that, for complex numbers, `std` takes the absolute

value before squaring, so that the result is always real and nonnegative.

For floating-point input, the *std* is computed using the same

precision the input has. Depending on the input data, this can cause
the results to be inaccurate, especially for float32 (see example below).
 Specifying a higher-accuracy accumulator using the `dtype` keyword can
alleviate this issue.

Examples
--------
>>> a = np.array([[1, 2], [3, 4]])
>>> np.std(a)
1.1180339887498949 # may vary
>>> np.std(a, axis=0)
array([1., 1.])
>>> np.std(a, axis=1)
array([0.5, 0.5])

In single precision, std() can be inaccurate:

>>> a = np.zeros((2, 512*512), dtype=np.float32)

>>> a[0, :] = 1.0
>>> a[1, :] = 0.1
>>> np.std(a)
0.45000005

Computing the standard deviation in float64 is more accurate:

>>> np.std(a, dtype=np.float64)

0.44999999925494177 # may vary

Specifying a where argument:

>>> a = np.array([[14, 8, 11, 10], [7, 9, 10, 11], [10, 15, 5, 10]])
>>> np.std(a)
2.614064523559687 # may vary
>>> np.std(a, where=[[True], [True], [False]])
2.0

sum(a, axis=None, dtype=None, out=None, keepdims=<no value>, initial=<no

value>, where=<no value>)
Sum of array elements over a given axis.

Parameters
----------
a : array_like
Elements to sum.
axis : None or int or tuple of ints, optional
Axis or axes along which a sum is performed. The default,
axis=None, will sum all of the elements of the input array. If
axis is negative it counts from the last to the first axis.

.. versionadded:: 1.7.0

If axis is a tuple of ints, a sum is performed on all of the axes

specified in the tuple instead of a single axis or all the axes as
before.
dtype : dtype, optional
The type of the returned array and of the accumulator in which the
elements are summed. The dtype of `a` is used by default unless `a`
has an integer dtype of less precision than the default platform
integer. In that case, if `a` is signed then the platform integer
is used while if `a` is unsigned then an unsigned integer of the
same precision as the platform integer is used.
out : ndarray, optional
Alternative output array in which to place the result. It must have
the same shape as the expected output, but the type of the output
values will be cast if necessary.
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 input array.

If the default value is passed, then `keepdims` will not be

passed through to the `sum` method of sub-classes of
`ndarray`, however any non-default value will be. If the
sub-class' method does not implement `keepdims` any
exceptions will be raised.
initial : scalar, optional
Starting value for the sum. See `~numpy.ufunc.reduce` for details.

.. versionadded:: 1.15.0

where : array_like of bool, optional

Elements to include in the sum. See `~numpy.ufunc.reduce` for details.

.. versionadded:: 1.17.0

Returns
-------
sum_along_axis : ndarray
An array with the same shape as `a`, with the specified
axis removed. If `a` is a 0-d array, or if `axis` is None, a scalar
is returned. If an output array is specified, a reference to
`out` is returned.

See Also
--------
ndarray.sum : Equivalent method.

add.reduce : Equivalent functionality of `add`.

cumsum : Cumulative sum of array elements.

trapz : Integration of array values using the composite trapezoidal rule.

mean, average

Notes
-----
Arithmetic is modular when using integer types, and no error is
raised on overflow.

The sum of an empty array is the neutral element 0:

>>> np.sum([])
0.0

For floating point numbers the numerical precision of sum (and

``np.add.reduce``) is in general limited by directly adding each number
individually to the result causing rounding errors in every step.
However, often numpy will use a numerically better approach (partial
pairwise summation) leading to improved precision in many use-cases.
 This improved precision is always provided when no ``axis`` is given.
When ``axis`` is given, it will depend on which axis is summed.
Technically, to provide the best speed possible, the improved precision
is only used when the summation is along the fast axis in memory.
Note that the exact precision may vary depending on other parameters.
In contrast to NumPy, Python's ``math.fsum`` function uses a slower but
more precise approach to summation.
Especially when summing a large number of lower precision floating point
numbers, such as ``float32``, numerical errors can become significant.
In such cases it can be advisable to use `dtype="float64"` to use a higher
precision for the output.

Examples
--------
>>> np.sum([0.5, 1.5])
2.0
>>> np.sum([0.5, 0.7, 0.2, 1.5], dtype=np.int32)
1
>>> np.sum([[0, 1], [0, 5]])
6
>>> np.sum([[0, 1], [0, 5]], axis=0)
array([0, 6])
>>> np.sum([[0, 1], [0, 5]], axis=1)
array([1, 5])
>>> np.sum([[0, 1], [np.nan, 5]], where=[False, True], axis=1)
array([1., 5.])

If the accumulator is too small, overflow occurs:

>>> np.ones(128, dtype=np.int8).sum(dtype=np.int8)

-128

You can also start the sum with a value other than zero:

>>> np.sum([10], initial=5)

15

swapaxes(a, axis1, axis2)

Interchange two axes of an array.

Parameters
----------
a : array_like
Input array.
axis1 : int
First axis.
axis2 : int
Second axis.

Returns
-------
a_swapped : ndarray
For NumPy >= 1.10.0, if `a` is an ndarray, then a view of `a` is
returned; otherwise a new array is created. For earlier NumPy
versions a view of `a` is returned only if the order of the
axes is changed, otherwise the input array is returned.

Examples
--------
 >>> x = np.array([[1,2,3]])
>>> np.swapaxes(x,0,1)
array([[1],
[2],
[3]])

>>> x = np.array([[[0,1],[2,3]],[[4,5],[6,7]]])
>>> x
array([[[0, 1],
[2, 3]],
[[4, 5],
[6, 7]]])

>>> np.swapaxes(x,0,2)
array([[[0, 4],
[2, 6]],
[[1, 5],
[3, 7]]])

take(a, indices, axis=None, out=None, mode='raise')

Take elements from an array along an axis.

When axis is not None, this function does the same thing as "fancy"
indexing (indexing arrays using arrays); however, it can be easier to use
if you need elements along a given axis. A call such as
``np.take(arr, indices, axis=3)`` is equivalent to
``arr[:,:,:,indices,...]``.

Explained without fancy indexing, this is equivalent to the following use

of `ndindex`, which sets each of ``ii``, ``jj``, and ``kk`` to a tuple of
indices::

Ni, Nk = a.shape[:axis], a.shape[axis+1:]

Nj = indices.shape
for ii in ndindex(Ni):
for jj in ndindex(Nj):
for kk in ndindex(Nk):
out[ii + jj + kk] = a[ii + (indices[jj],) + kk]

Parameters
----------
a : array_like (Ni..., M, Nk...)
The source array.
indices : array_like (Nj...)
The indices of the values to extract.

.. versionadded:: 1.8.0

Also allow scalars for indices.

axis : int, optional
The axis over which to select values. By default, the flattened
input array is used.
out : ndarray, optional (Ni..., Nj..., Nk...)
If provided, the result will be placed in this array. It should
be of the appropriate shape and dtype. Note that `out` is always
buffered if `mode='raise'`; use other modes for better performance.
mode : {'raise', 'wrap', 'clip'}, optional
Specifies how out-of-bounds indices will behave.
 * 'raise' -- raise an error (default)
* 'wrap' -- wrap around
* 'clip' -- clip to the range

'clip' mode means that all indices that are too large are replaced
by the index that addresses the last element along that axis. Note
that this disables indexing with negative numbers.

Returns
-------
out : ndarray (Ni..., Nj..., Nk...)
The returned array has the same type as `a`.

See Also
--------
compress : Take elements using a boolean mask
ndarray.take : equivalent method
take_along_axis : Take elements by matching the array and the index arrays

Notes
-----

By eliminating the inner loop in the description above, and using `s_` to
build simple slice objects, `take` can be expressed in terms of applying
fancy indexing to each 1-d slice::

Ni, Nk = a.shape[:axis], a.shape[axis+1:]

for ii in ndindex(Ni):
for kk in ndindex(Nj):
out[ii + s_[...,] + kk] = a[ii + s_[:,] + kk][indices]

For this reason, it is equivalent to (but faster than) the following use
of `apply_along_axis`::

out = np.apply_along_axis(lambda a_1d: a_1d[indices], axis, a)

Examples
--------
>>> a = [4, 3, 5, 7, 6, 8]
>>> indices = [0, 1, 4]
>>> np.take(a, indices)
array([4, 3, 6])

In this example if `a` is an ndarray, "fancy" indexing can be used.

>>> a = np.array(a)
>>> a[indices]
array([4, 3, 6])

If `indices` is not one dimensional, the output also has these dimensions.

>>> np.take(a, [[0, 1], [2, 3]])

array([[4, 3],
[5, 7]])

take_along_axis(arr, indices, axis)

Take values from the input array by matching 1d index and data slices.

This iterates over matching 1d slices oriented along the specified axis in
 the index and data arrays, and uses the former to look up values in the
latter. These slices can be different lengths.

Functions returning an index along an axis, like `argsort` and

`argpartition`, produce suitable indices for this function.

.. versionadded:: 1.15.0

Parameters
----------
arr : ndarray (Ni..., M, Nk...)
Source array
indices : ndarray (Ni..., J, Nk...)
Indices to take along each 1d slice of `arr`. This must match the
dimension of arr, but dimensions Ni and Nj only need to broadcast
against `arr`.
axis : int
The axis to take 1d slices along. If axis is None, the input array is
treated as if it had first been flattened to 1d, for consistency with
`sort` and `argsort`.

Returns
-------
out: ndarray (Ni..., J, Nk...)
The indexed result.

Notes
-----
This is equivalent to (but faster than) the following use of `ndindex` and
`s_`, which sets each of ``ii`` and ``kk`` to a tuple of indices::

Ni, M, Nk = a.shape[:axis], a.shape[axis], a.shape[axis+1:]

J = indices.shape[axis] # Need not equal M
out = np.empty(Ni + (J,) + Nk)

for ii in ndindex(Ni):
for kk in ndindex(Nk):
a_1d = a [ii + s_[:,] + kk]
indices_1d = indices[ii + s_[:,] + kk]
out_1d = out [ii + s_[:,] + kk]
for j in range(J):
out_1d[j] = a_1d[indices_1d[j]]

Equivalently, eliminating the inner loop, the last two lines would be::

out_1d[:] = a_1d[indices_1d]

See Also
--------
take : Take along an axis, using the same indices for every 1d slice
put_along_axis :
Put values into the destination array by matching 1d index and data
slices

Examples
--------

For this sample array

 >>> a = np.array([[10, 30, 20], [60, 40, 50]])

We can sort either by using sort directly, or argsort and this function

>>> np.sort(a, axis=1)

array([[10, 20, 30],
[40, 50, 60]])
>>> ai = np.argsort(a, axis=1)
>>> ai
array([[0, 2, 1],
[1, 2, 0]])
>>> np.take_along_axis(a, ai, axis=1)
array([[10, 20, 30],
[40, 50, 60]])

The same works for max and min, if you maintain the trivial dimension
with ``keepdims``:

>>> np.max(a, axis=1, keepdims=True)

array([[30],
[60]])
>>> ai = np.argmax(a, axis=1, keepdims=True)
>>> ai
array([[1],
[0]])
>>> np.take_along_axis(a, ai, axis=1)
array([[30],
[60]])

If we want to get the max and min at the same time, we can stack the
indices first

>>> ai_min = np.argmin(a, axis=1, keepdims=True)

>>> ai_max = np.argmax(a, axis=1, keepdims=True)
>>> ai = np.concatenate([ai_min, ai_max], axis=1)
>>> ai
array([[0, 1],
[1, 0]])
>>> np.take_along_axis(a, ai, axis=1)
array([[10, 30],
[40, 60]])

tensordot(a, b, axes=2)
Compute tensor dot product along specified axes.

Given two tensors, `a` and `b`, and an array_like object containing
two array_like objects, ``(a_axes, b_axes)``, sum the products of
`a`'s and `b`'s elements (components) over the axes specified by
``a_axes`` and ``b_axes``. The third argument can be a single non-negative
integer_like scalar, ``N``; if it is such, then the last ``N`` dimensions
of `a` and the first ``N`` dimensions of `b` are summed over.

Parameters
----------
a, b : array_like
Tensors to "dot".

axes : int or (2,) array_like

* integer_like
 If an int N, sum over the last N axes of `a` and the first N axes
of `b` in order. The sizes of the corresponding axes must match.
* (2,) array_like
Or, a list of axes to be summed over, first sequence applying to `a`,
second to `b`. Both elements array_like must be of the same length.

Returns
-------
output : ndarray
The tensor dot product of the input.

See Also
--------
dot, einsum

Notes
-----
Three common use cases are:
* ``axes = 0`` : tensor product :math:`a\otimes b`
* ``axes = 1`` : tensor dot product :math:`a\cdot b`
* ``axes = 2`` : (default) tensor double contraction :math:`a:b`

When `axes` is integer_like, the sequence for evaluation will be: first
the -Nth axis in `a` and 0th axis in `b`, and the -1th axis in `a` and
Nth axis in `b` last.

When there is more than one axis to sum over - and they are not the last
(first) axes of `a` (`b`) - the argument `axes` should consist of
two sequences of the same length, with the first axis to sum over given
first in both sequences, the second axis second, and so forth.

The shape of the result consists of the non-contracted axes of the

first tensor, followed by the non-contracted axes of the second.

Examples
--------
A "traditional" example:

>>> a = np.arange(60.).reshape(3,4,5)
>>> b = np.arange(24.).reshape(4,3,2)
>>> c = np.tensordot(a,b, axes=([1,0],[0,1]))
>>> c.shape
(5, 2)
>>> c
array([[4400., 4730.],
[4532., 4874.],
[4664., 5018.],
[4796., 5162.],
[4928., 5306.]])
>>> # A slower but equivalent way of computing the same...
>>> d = np.zeros((5,2))
>>> for i in range(5):
... for j in range(2):
... for k in range(3):
... for n in range(4):
... d[i,j] += a[k,n,i] * b[n,k,j]
>>> c == d
array([[ True, True],
[ True, True],
 [ True, True],
[ True, True],
[ True, True]])

An extended example taking advantage of the overloading of + and \*:

>>> a = np.array(range(1, 9))

>>> a.shape = (2, 2, 2)
>>> A = np.array(('a', 'b', 'c', 'd'), dtype=object)
>>> A.shape = (2, 2)
>>> a; A
array([[[1, 2],
[3, 4]],
[[5, 6],
[7, 8]]])
array([['a', 'b'],
['c', 'd']], dtype=object)

>>> np.tensordot(a, A) # third argument default is 2 for double-contraction

array(['abbcccdddd', 'aaaaabbbbbbcccccccdddddddd'], dtype=object)

>>> np.tensordot(a, A, 1)
array([[['acc', 'bdd'],
['aaacccc', 'bbbdddd']],
[['aaaaacccccc', 'bbbbbdddddd'],
['aaaaaaacccccccc', 'bbbbbbbdddddddd']]], dtype=object)

>>> np.tensordot(a, A, 0) # tensor product (result too long to incl.)

array([[[[['a', 'b'],
['c', 'd']],
...

>>> np.tensordot(a, A, (0, 1))

array([[['abbbbb', 'cddddd'],
['aabbbbbb', 'ccdddddd']],
[['aaabbbbbbb', 'cccddddddd'],
['aaaabbbbbbbb', 'ccccdddddddd']]], dtype=object)

>>> np.tensordot(a, A, (2, 1))

array([[['abb', 'cdd'],
['aaabbbb', 'cccdddd']],
[['aaaaabbbbbb', 'cccccdddddd'],
['aaaaaaabbbbbbbb', 'cccccccdddddddd']]], dtype=object)

>>> np.tensordot(a, A, ((0, 1), (0, 1)))

array(['abbbcccccddddddd', 'aabbbbccccccdddddddd'], dtype=object)

>>> np.tensordot(a, A, ((2, 1), (1, 0)))

array(['acccbbdddd', 'aaaaacccccccbbbbbbdddddddd'], dtype=object)

tile(A, reps)
Construct an array by repeating A the number of times given by reps.

If `reps` has length ``d``, the result will have dimension of

``max(d, A.ndim)``.

If ``A.ndim < d``, `A` is promoted to be d-dimensional by prepending new

axes. So a shape (3,) array is promoted to (1, 3) for 2-D replication,
or shape (1, 1, 3) for 3-D replication. If this is not the desired
 behavior, promote `A` to d-dimensions manually before calling this
function.

If ``A.ndim > d``, `reps` is promoted to `A`.ndim by pre-pending 1's to it.

Thus for an `A` of shape (2, 3, 4, 5), a `reps` of (2, 2) is treated as
(1, 1, 2, 2).

Note : Although tile may be used for broadcasting, it is strongly

recommended to use numpy's broadcasting operations and functions.

Parameters
----------
A : array_like
The input array.
reps : array_like
The number of repetitions of `A` along each axis.

Returns
-------
c : ndarray
The tiled output array.

See Also
--------
repeat : Repeat elements of an array.
broadcast_to : Broadcast an array to a new shape

Examples
--------
>>> a = np.array([0, 1, 2])
>>> np.tile(a, 2)
array([0, 1, 2, 0, 1, 2])
>>> np.tile(a, (2, 2))
array([[0, 1, 2, 0, 1, 2],
[0, 1, 2, 0, 1, 2]])
>>> np.tile(a, (2, 1, 2))
array([[[0, 1, 2, 0, 1, 2]],
[[0, 1, 2, 0, 1, 2]]])

>>> b = np.array([[1, 2], [3, 4]])

>>> np.tile(b, 2)
array([[1, 2, 1, 2],
[3, 4, 3, 4]])
>>> np.tile(b, (2, 1))
array([[1, 2],
[3, 4],
[1, 2],
[3, 4]])

>>> c = np.array([1,2,3,4])
>>> np.tile(c,(4,1))
array([[1, 2, 3, 4],
[1, 2, 3, 4],
[1, 2, 3, 4],
[1, 2, 3, 4]])

trace(a, offset=0, axis1=0, axis2=1, dtype=None, out=None)

Return the sum along diagonals of the array.
 If `a` is 2-D, the sum along its diagonal with the given offset
is returned, i.e., the sum of elements ``a[i,i+offset]`` for all i.

If `a` has more than two dimensions, then the axes specified by axis1 and
axis2 are used to determine the 2-D sub-arrays whose traces are returned.
The shape of the resulting array is the same as that of `a` with `axis1`
and `axis2` removed.

Parameters
----------
a : array_like
Input array, from which the diagonals are taken.
offset : int, optional
Offset of the diagonal from the main diagonal. Can be both positive
and negative. Defaults to 0.
axis1, axis2 : int, optional
Axes to be used as the first and second axis of the 2-D sub-arrays
from which the diagonals should be taken. Defaults are the first two
axes of `a`.
dtype : dtype, optional
Determines the data-type of the returned array and of the accumulator
where the elements are summed. If dtype has the value None and `a` is
of integer type of precision less than the default integer
precision, then the default integer precision is used. Otherwise,
the precision is the same as that of `a`.
out : ndarray, optional
Array into which the output is placed. Its type is preserved and
it must be of the right shape to hold the output.

Returns
-------
sum_along_diagonals : ndarray
If `a` is 2-D, the sum along the diagonal is returned. If `a` has
larger dimensions, then an array of sums along diagonals is returned.

See Also
--------
diag, diagonal, diagflat

Examples
--------
>>> np.trace(np.eye(3))
3.0
>>> a = np.arange(8).reshape((2,2,2))
>>> np.trace(a)
array([6, 8])

>>> a = np.arange(24).reshape((2,2,2,3))
>>> np.trace(a).shape
(2, 3)

transpose(a, axes=None)
Returns an array with axes transposed.

For a 1-D array, this returns an unchanged view of the original array, as a
transposed vector is simply the same vector.
To convert a 1-D array into a 2-D column vector, an additional dimension
must be added, e.g., ``np.atleast2d(a).T`` achieves this, as does
``a[:, np.newaxis]``.
 For a 2-D array, this is the 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, then
``transpose(a).shape == a.shape[::-1]``.

Parameters
----------
a : array_like
Input array.
axes : tuple or list of ints, optional
If specified, it must be a tuple or list which contains a permutation
of [0,1,...,N-1] where N is the number of axes of `a`. The `i`'th axis
of the returned array will correspond to the axis numbered ``axes[i]``
of the input. If not specified, defaults to ``range(a.ndim)[::-1]``,
which reverses the order of the axes.

Returns
-------
p : ndarray
`a` with its axes permuted. A view is returned whenever possible.

See Also
--------
ndarray.transpose : Equivalent method.
moveaxis : Move axes of an array to new positions.
argsort : Return the indices that would sort an array.

Notes
-----
Use ``transpose(a, argsort(axes))`` to invert the transposition of tensors
when using the `axes` keyword argument.

Examples
--------
>>> a = np.array([[1, 2], [3, 4]])
>>> a
array([[1, 2],
[3, 4]])
>>> np.transpose(a)
array([[1, 3],
[2, 4]])

>>> a = np.array([1, 2, 3, 4])

>>> a
array([1, 2, 3, 4])
>>> np.transpose(a)
array([1, 2, 3, 4])

>>> a = np.ones((1, 2, 3))

>>> np.transpose(a, (1, 0, 2)).shape
(2, 1, 3)

>>> a = np.ones((2, 3, 4, 5))

>>> np.transpose(a).shape
(5, 4, 3, 2)

trapz(y, x=None, dx=1.0, axis=-1)

Integrate along the given axis using the composite trapezoidal rule.
 If `x` is provided, the integration happens in sequence along its
elements - they are not sorted.

Integrate `y` (`x`) along each 1d slice on the given axis, compute
:math:`\int y(x) dx`.
When `x` is specified, this integrates along the parametric curve,
computing :math:`\int_t y(t) dt =
\int_t y(t) \left.\frac{dx}{dt}\right|_{x=x(t)} dt`.

Parameters
----------
y : array_like
Input array to integrate.
x : array_like, optional
The sample points corresponding to the `y` values. If `x` is None,
the sample points are assumed to be evenly spaced `dx` apart. The
default is None.
dx : scalar, optional
The spacing between sample points when `x` is None. The default is 1.
axis : int, optional
The axis along which to integrate.

Returns
-------
trapz : float or ndarray
Definite integral of `y` = n-dimensional array as approximated along
a single axis by the trapezoidal rule. If `y` is a 1-dimensional array,
then the result is a float. If `n` is greater than 1, then the result
is an `n`-1 dimensional array.

See Also
--------
sum, cumsum

Notes
-----
Image [2]_ illustrates trapezoidal rule -- y-axis locations of points
will be taken from `y` array, by default x-axis distances between
points will be 1.0, alternatively they can be provided with `x` array
or with `dx` scalar. Return value will be equal to combined area under
the red lines.

References
----------
.. [1] Wikipedia page: https://en.wikipedia.org/wiki/Trapezoidal_rule

.. [2] Illustration image:

https://en.wikipedia.org/wiki/File:Composite_trapezoidal_rule_illustration.png

Examples
--------
Use the trapezoidal rule on evenly spaced points:

>>> np.trapz([1, 2, 3])

4.0

The spacing between sample points can be selected by either the

 ``x`` or ``dx`` arguments:

>>> np.trapz([1, 2, 3], x=[4, 6, 8])

8.0
>>> np.trapz([1, 2, 3], dx=2)
8.0

Using a decreasing ``x`` corresponds to integrating in reverse:

>>> np.trapz([1, 2, 3], x=[8, 6, 4])

-8.0

More generally ``x`` is used to integrate along a parametric curve. We can

estimate the integral :math:`\int_0^1 x^2 = 1/3` using:

>>> x = np.linspace(0, 1, num=50)

>>> y = x**2
>>> np.trapz(y, x)
0.33340274885464394

Or estimate the area of a circle, noting we repeat the sample which closes
the curve:

>>> theta = np.linspace(0, 2 * np.pi, num=1000, endpoint=True)

>>> np.trapz(np.cos(theta), x=np.sin(theta))
3.141571941375841

``np.trapz`` can be applied along a specified axis to do multiple

computations in one call:

>>> a = np.arange(6).reshape(2, 3)
>>> a
array([[0, 1, 2],
[3, 4, 5]])
>>> np.trapz(a, axis=0)
array([1.5, 2.5, 3.5])
>>> np.trapz(a, axis=1)
array([2., 8.])

tri(N, M=None, k=0, dtype=<class 'float'>, *, like=None)

An array with ones at and below the given diagonal and zeros elsewhere.

Parameters
----------
N : int
Number of rows in the array.
M : int, optional
Number of columns in the array.
By default, `M` is taken equal to `N`.
k : int, optional
The sub-diagonal at and below which the array is filled.
`k` = 0 is the main diagonal, while `k` < 0 is below it,
and `k` > 0 is above. The default is 0.
dtype : dtype, optional
Data type of the returned array. The default is float.
like : array_like, optional
Reference object to allow the creation of arrays which are not
NumPy arrays. If an array-like passed in as ``like`` supports
the ``__array_function__`` protocol, the result will be defined
 by it. In this case, it ensures the creation of an array object
compatible with that passed in via this argument.

.. versionadded:: 1.20.0

Returns
-------
tri : ndarray of shape (N, M)
Array with its lower triangle filled with ones and zero elsewhere;
in other words ``T[i,j] == 1`` for ``j <= i + k``, 0 otherwise.

Examples
--------
>>> np.tri(3, 5, 2, dtype=int)
array([[1, 1, 1, 0, 0],
[1, 1, 1, 1, 0],
[1, 1, 1, 1, 1]])

>>> np.tri(3, 5, -1)

array([[0., 0., 0., 0., 0.],
[1., 0., 0., 0., 0.],
[1., 1., 0., 0., 0.]])

tril(m, k=0)
Lower triangle of an array.

Return a copy of an array with elements above the `k`-th diagonal zeroed.
For arrays with ``ndim`` exceeding 2, `tril` will apply to the final two
axes.

Parameters
----------
m : array_like, shape (..., M, N)
Input array.
k : int, optional
Diagonal above which to zero elements. `k = 0` (the default) is the
main diagonal, `k < 0` is below it and `k > 0` is above.

Returns
-------
tril : ndarray, shape (..., M, N)
Lower triangle of `m`, of same shape and data-type as `m`.

See Also
--------
triu : same thing, only for the upper triangle

Examples
--------
>>> np.tril([[1,2,3],[4,5,6],[7,8,9],[10,11,12]], -1)
array([[ 0, 0, 0],
[ 4, 0, 0],
[ 7, 8, 0],
[10, 11, 12]])

>>> np.tril(np.arange(3*4*5).reshape(3, 4, 5))

array([[[ 0, 0, 0, 0, 0],
[ 5, 6, 0, 0, 0],
[10, 11, 12, 0, 0],
 [15, 16, 17, 18, 0]],
[[20, 0, 0, 0, 0],
[25, 26, 0, 0, 0],
[30, 31, 32, 0, 0],
[35, 36, 37, 38, 0]],
[[40, 0, 0, 0, 0],
[45, 46, 0, 0, 0],
[50, 51, 52, 0, 0],
[55, 56, 57, 58, 0]]])

tril_indices(n, k=0, m=None)

Return the indices for the lower-triangle of an (n, m) array.

Parameters
----------
n : int
The row dimension of the arrays for which the returned
indices will be valid.
k : int, optional
Diagonal offset (see `tril` for details).
m : int, optional
.. versionadded:: 1.9.0

The column dimension of the arrays for which the returned

arrays will be valid.
By default `m` is taken equal to `n`.

Returns
-------
inds : tuple of arrays
The indices for the triangle. The returned tuple contains two arrays,
each with the indices along one dimension of the array.

See also
--------
triu_indices : similar function, for upper-triangular.
mask_indices : generic function accepting an arbitrary mask function.
tril, triu

Notes
-----
.. versionadded:: 1.4.0

Examples
--------
Compute two different sets of indices to access 4x4 arrays, one for the
lower triangular part starting at the main diagonal, and one starting two
diagonals further right:

>>> il1 = np.tril_indices(4)

>>> il2 = np.tril_indices(4, 2)

Here is how they can be used with a sample array:

>>> a = np.arange(16).reshape(4, 4)
>>> a
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
 [ 8, 9, 10, 11],
[12, 13, 14, 15]])

Both for indexing:

>>> a[il1]
array([ 0, 4, 5, ..., 13, 14, 15])

And for assigning values:

>>> a[il1] = -1
>>> a
array([[-1, 1, 2, 3],
[-1, -1, 6, 7],
[-1, -1, -1, 11],
[-1, -1, -1, -1]])

These cover almost the whole array (two diagonals right of the main one):

>>> a[il2] = -10

>>> a
array([[-10, -10, -10, 3],
[-10, -10, -10, -10],
[-10, -10, -10, -10],
[-10, -10, -10, -10]])

tril_indices_from(arr, k=0)
Return the indices for the lower-triangle of arr.

See `tril_indices` for full details.

Parameters
----------
arr : array_like
The indices will be valid for square arrays whose dimensions are
the same as arr.
k : int, optional
Diagonal offset (see `tril` for details).

Examples
--------

Create a 4 by 4 array.

>>> a = np.arange(16).reshape(4, 4)
>>> a
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11],
[12, 13, 14, 15]])

Pass the array to get the indices of the lower triangular elements.

>>> trili = np.tril_indices_from(a)

>>> trili
(array([0, 1, 1, 2, 2, 2, 3, 3, 3, 3]), array([0, 0, 1, 0, 1, 2, 0, 1, 2,
3]))

>>> a[trili]
 array([ 0, 4, 5, 8, 9, 10, 12, 13, 14, 15])

This is syntactic sugar for tril_indices().

>>> np.tril_indices(a.shape[0])
(array([0, 1, 1, 2, 2, 2, 3, 3, 3, 3]), array([0, 0, 1, 0, 1, 2, 0, 1, 2,
3]))

Use the `k` parameter to return the indices for the lower triangular array
up to the k-th diagonal.

>>> trili1 = np.tril_indices_from(a, k=1)

>>> a[trili1]
array([ 0, 1, 4, 5, 6, 8, 9, 10, 11, 12, 13, 14, 15])

See Also
--------
tril_indices, tril, triu_indices_from

Notes
-----
.. versionadded:: 1.4.0

trim_zeros(filt, trim='fb')
Trim the leading and/or trailing zeros from a 1-D array or sequence.

Parameters
----------
filt : 1-D array or sequence
Input array.
trim : str, optional
A string with 'f' representing trim from front and 'b' to trim from
back. Default is 'fb', trim zeros from both front and back of the
array.

Returns
-------
trimmed : 1-D array or sequence
The result of trimming the input. The input data type is preserved.

Examples
--------
>>> a = np.array((0, 0, 0, 1, 2, 3, 0, 2, 1, 0))
>>> np.trim_zeros(a)
array([1, 2, 3, 0, 2, 1])

>>> np.trim_zeros(a, 'b')

array([0, 0, 0, ..., 0, 2, 1])

The input data type is preserved, list/tuple in means list/tuple out.

>>> np.trim_zeros([0, 1, 2, 0])

[1, 2]

triu(m, k=0)
Upper triangle of an array.

Return a copy of an array with the elements below the `k`-th diagonal
zeroed. For arrays with ``ndim`` exceeding 2, `triu` will apply to the
 final two axes.

Please refer to the documentation for `tril` for further details.

See Also
--------
tril : lower triangle of an array

Examples
--------
>>> np.triu([[1,2,3],[4,5,6],[7,8,9],[10,11,12]], -1)
array([[ 1, 2, 3],
[ 4, 5, 6],
[ 0, 8, 9],
[ 0, 0, 12]])

>>> np.triu(np.arange(3*4*5).reshape(3, 4, 5))

array([[[ 0, 1, 2, 3, 4],
[ 0, 6, 7, 8, 9],
[ 0, 0, 12, 13, 14],
[ 0, 0, 0, 18, 19]],
[[20, 21, 22, 23, 24],
[ 0, 26, 27, 28, 29],
[ 0, 0, 32, 33, 34],
[ 0, 0, 0, 38, 39]],
[[40, 41, 42, 43, 44],
[ 0, 46, 47, 48, 49],
[ 0, 0, 52, 53, 54],
[ 0, 0, 0, 58, 59]]])

triu_indices(n, k=0, m=None)

Return the indices for the upper-triangle of an (n, m) array.

Parameters
----------
n : int
The size of the arrays for which the returned indices will
be valid.
k : int, optional
Diagonal offset (see `triu` for details).
m : int, optional
.. versionadded:: 1.9.0

The column dimension of the arrays for which the returned

arrays will be valid.
By default `m` is taken equal to `n`.

Returns
-------
inds : tuple, shape(2) of ndarrays, shape(`n`)
The indices for the triangle. The returned tuple contains two arrays,
each with the indices along one dimension of the array. Can be used
to slice a ndarray of shape(`n`, `n`).

See also
--------
tril_indices : similar function, for lower-triangular.
mask_indices : generic function accepting an arbitrary mask function.
 triu, tril

Notes
-----
.. versionadded:: 1.4.0

Examples
--------
Compute two different sets of indices to access 4x4 arrays, one for the
upper triangular part starting at the main diagonal, and one starting two
diagonals further right:

>>> iu1 = np.triu_indices(4)

>>> iu2 = np.triu_indices(4, 2)

Here is how they can be used with a sample array:

>>> a = np.arange(16).reshape(4, 4)
>>> a
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11],
[12, 13, 14, 15]])

Both for indexing:

>>> a[iu1]
array([ 0, 1, 2, ..., 10, 11, 15])

And for assigning values:

>>> a[iu1] = -1
>>> a
array([[-1, -1, -1, -1],
[ 4, -1, -1, -1],
[ 8, 9, -1, -1],
[12, 13, 14, -1]])

These cover only a small part of the whole array (two diagonals right
of the main one):

>>> a[iu2] = -10

>>> a
array([[ -1, -1, -10, -10],
[ 4, -1, -1, -10],
[ 8, 9, -1, -1],
[ 12, 13, 14, -1]])

triu_indices_from(arr, k=0)
Return the indices for the upper-triangle of arr.

See `triu_indices` for full details.

Parameters
----------
arr : ndarray, shape(N, N)
The indices will be valid for square arrays.
k : int, optional
Diagonal offset (see `triu` for details).
 Returns
-------
triu_indices_from : tuple, shape(2) of ndarray, shape(N)
Indices for the upper-triangle of `arr`.

Examples
--------

Create a 4 by 4 array.

>>> a = np.arange(16).reshape(4, 4)
>>> a
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11],
[12, 13, 14, 15]])

Pass the array to get the indices of the upper triangular elements.

>>> triui = np.triu_indices_from(a)

>>> triui
(array([0, 0, 0, 0, 1, 1, 1, 2, 2, 3]), array([0, 1, 2, 3, 1, 2, 3, 2, 3,
3]))

>>> a[triui]
array([ 0, 1, 2, 3, 5, 6, 7, 10, 11, 15])

This is syntactic sugar for triu_indices().

>>> np.triu_indices(a.shape[0])
(array([0, 0, 0, 0, 1, 1, 1, 2, 2, 3]), array([0, 1, 2, 3, 1, 2, 3, 2, 3,
3]))

Use the `k` parameter to return the indices for the upper triangular array
from the k-th diagonal.

>>> triuim1 = np.triu_indices_from(a, k=1)

>>> a[triuim1]
array([ 1, 2, 3, 6, 7, 11])

See Also
--------
triu_indices, triu, tril_indices_from

Notes
-----
.. versionadded:: 1.4.0

typename(char)
Return a description for the given data type code.

Parameters
----------
char : str
Data type code.

Returns
 -------
out : str
Description of the input data type code.

See Also
--------
dtype, typecodes

Examples
--------
>>> typechars = ['S1', '?', 'B', 'D', 'G', 'F', 'I', 'H', 'L', 'O', 'Q',
... 'S', 'U', 'V', 'b', 'd', 'g', 'f', 'i', 'h', 'l', 'q']
>>> for typechar in typechars:
... print(typechar, ' : ', np.typename(typechar))
...
S1 : character
? : bool
B : unsigned char
D : complex double precision
G : complex long double precision
F : complex single precision
I : unsigned integer
H : unsigned short
L : unsigned long integer
O : object
Q : unsigned long long integer
S : string
U : unicode
V : void
b : signed char
d : double precision
g : long precision
f : single precision
i : integer
h : short
l : long integer
q : long long integer

union1d(ar1, ar2)
Find the union of two arrays.

Return the unique, sorted array of values that are in either of the two
input arrays.

Parameters
----------
ar1, ar2 : array_like
Input arrays. They are flattened if they are not already 1D.

Returns
-------
union1d : ndarray
Unique, sorted union of the input arrays.

See Also
--------
numpy.lib.arraysetops : Module with a number of other functions for
performing set operations on arrays.
 Examples
--------
>>> np.union1d([-1, 0, 1], [-2, 0, 2])
array([-2, -1, 0, 1, 2])

To find the union of more than two arrays, use functools.reduce:

>>> from functools import reduce

>>> reduce(np.union1d, ([1, 3, 4, 3], [3, 1, 2, 1], [6, 3, 4, 2]))
array([1, 2, 3, 4, 6])

unique(ar, return_index=False, return_inverse=False, return_counts=False,

axis=None, *, equal_nan=True)
Find the unique elements of an array.

Returns the sorted unique elements of an array. There are three optional
outputs in addition to the unique elements:

* the indices of the input array that give the unique values
* the indices of the unique array that reconstruct the input array
* the number of times each unique value comes up in the input array

Parameters
----------
ar : array_like
Input array. Unless `axis` is specified, this will be flattened if it
is not already 1-D.
return_index : bool, optional
If True, also return the indices of `ar` (along the specified axis,
if provided, or in the flattened array) that result in the unique
array.
return_inverse : bool, optional
If True, also return the indices of the unique array (for the specified
axis, if provided) that can be used to reconstruct `ar`.
return_counts : bool, optional
If True, also return the number of times each unique item appears
in `ar`.
axis : int or None, optional
The axis to operate on. If None, `ar` will be flattened. If an integer,
the subarrays indexed by the given axis will be flattened and treated
as the elements of a 1-D array with the dimension of the given axis,
see the notes for more details. Object arrays or structured arrays
that contain objects are not supported if the `axis` kwarg is used. The
default is None.

.. versionadded:: 1.13.0

equal_nan : bool, optional

If True, collapses multiple NaN values in the return array into one.

.. versionadded:: 1.24

Returns
-------
unique : ndarray
The sorted unique values.
unique_indices : ndarray, optional
The indices of the first occurrences of the unique values in the
original array. Only provided if `return_index` is True.
 unique_inverse : ndarray, optional
The indices to reconstruct the original array from the
unique array. Only provided if `return_inverse` is True.
unique_counts : ndarray, optional
The number of times each of the unique values comes up in the
original array. Only provided if `return_counts` is True.

.. versionadded:: 1.9.0

See Also
--------
numpy.lib.arraysetops : Module with a number of other functions for
performing set operations on arrays.
repeat : Repeat elements of an array.

Notes
-----
When an axis is specified the subarrays indexed by the axis are sorted.
This is done by making the specified axis the first dimension of the array
(move the axis to the first dimension to keep the order of the other axes)
and then flattening the subarrays in C order. The flattened subarrays are
then viewed as a structured type with each element given a label, with the
effect that we end up with a 1-D array of structured types that can be
treated in the same way as any other 1-D array. The result is that the
flattened subarrays are sorted in lexicographic order starting with the
first element.

.. versionchanged: NumPy 1.21

If nan values are in the input array, a single nan is put
to the end of the sorted unique values.

Also for complex arrays all NaN values are considered equivalent
(no matter whether the NaN is in the real or imaginary part).
As the representant for the returned array the smallest one in the
lexicographical order is chosen - see np.sort for how the
lexicographical
order is defined for complex arrays.

Examples
--------
>>> np.unique([1, 1, 2, 2, 3, 3])
array([1, 2, 3])
>>> a = np.array([[1, 1], [2, 3]])
>>> np.unique(a)
array([1, 2, 3])

Return the unique rows of a 2D array

>>> a = np.array([[1, 0, 0], [1, 0, 0], [2, 3, 4]])

>>> np.unique(a, axis=0)
array([[1, 0, 0], [2, 3, 4]])

Return the indices of the original array that give the unique values:

>>> a = np.array(['a', 'b', 'b', 'c', 'a'])

>>> u, indices = np.unique(a, return_index=True)
>>> u
array(['a', 'b', 'c'], dtype='<U1')
>>> indices
 array([0, 1, 3])
>>> a[indices]
array(['a', 'b', 'c'], dtype='<U1')

Reconstruct the input array from the unique values and inverse:

>>> a = np.array([1, 2, 6, 4, 2, 3, 2])

>>> u, indices = np.unique(a, return_inverse=True)
>>> u
array([1, 2, 3, 4, 6])
>>> indices
array([0, 1, 4, 3, 1, 2, 1])
>>> u[indices]
array([1, 2, 6, 4, 2, 3, 2])

Reconstruct the input values from the unique values and counts:

>>> a = np.array([1, 2, 6, 4, 2, 3, 2])

>>> values, counts = np.unique(a, return_counts=True)
>>> values
array([1, 2, 3, 4, 6])
>>> counts
array([1, 3, 1, 1, 1])
>>> np.repeat(values, counts)
array([1, 2, 2, 2, 3, 4, 6]) # original order not preserved

unpackbits(...)
unpackbits(a, /, axis=None, count=None, bitorder='big')

Unpacks elements of a uint8 array into a binary-valued output array.

Each element of `a` represents a bit-field that should be unpacked

into a binary-valued output array. The shape of the output array is
either 1-D (if `axis` is ``None``) or the same shape as the input
array with unpacking done along the axis specified.

Parameters
----------
a : ndarray, uint8 type
Input array.
axis : int, optional
The dimension over which bit-unpacking is done.
``None`` implies unpacking the flattened array.
count : int or None, optional
The number of elements to unpack along `axis`, provided as a way
of undoing the effect of packing a size that is not a multiple
of eight. A non-negative number means to only unpack `count`
bits. A negative number means to trim off that many bits from
the end. ``None`` means to unpack the entire array (the
default). Counts larger than the available number of bits will
add zero padding to the output. Negative counts must not
exceed the available number of bits.

.. versionadded:: 1.17.0

bitorder : {'big', 'little'}, optional

The order of the returned bits. 'big' will mimic bin(val),
``3 = 0b00000011 => [0, 0, 0, 0, 0, 0, 1, 1]``, 'little' will reverse
the order to ``[1, 1, 0, 0, 0, 0, 0, 0]``.
 Defaults to 'big'.

.. versionadded:: 1.17.0

Returns
-------
unpacked : ndarray, uint8 type
The elements are binary-valued (0 or 1).

See Also
--------
packbits : Packs the elements of a binary-valued array into bits in
a uint8 array.

Examples
--------
>>> a = np.array([[2], [7], [23]], dtype=np.uint8)
>>> a
array([[ 2],
[ 7],
[23]], dtype=uint8)
>>> b = np.unpackbits(a, axis=1)
>>> b
array([[0, 0, 0, 0, 0, 0, 1, 0],
[0, 0, 0, 0, 0, 1, 1, 1],
[0, 0, 0, 1, 0, 1, 1, 1]], dtype=uint8)
>>> c = np.unpackbits(a, axis=1, count=-3)
>>> c
array([[0, 0, 0, 0, 0],
[0, 0, 0, 0, 0],
[0, 0, 0, 1, 0]], dtype=uint8)

>>> p = np.packbits(b, axis=0)

>>> np.unpackbits(p, axis=0)
array([[0, 0, 0, 0, 0, 0, 1, 0],
[0, 0, 0, 0, 0, 1, 1, 1],
[0, 0, 0, 1, 0, 1, 1, 1],
[0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0]], dtype=uint8)
>>> np.array_equal(b, np.unpackbits(p, axis=0, count=b.shape[0]))
True

unravel_index(...)
unravel_index(indices, shape, order='C')

Converts a flat index or array of flat indices into a tuple

of coordinate arrays.

Parameters
----------
indices : array_like
An integer array whose elements are indices into the flattened
version of an array of dimensions ``shape``. Before version 1.6.0,
this function accepted just one index value.
shape : tuple of ints
The shape of the array to use for unraveling ``indices``.
 .. versionchanged:: 1.16.0
Renamed from ``dims`` to ``shape``.

order : {'C', 'F'}, optional

Determines whether the indices should be viewed as indexing in
row-major (C-style) or column-major (Fortran-style) order.

.. versionadded:: 1.6.0

Returns
-------
unraveled_coords : tuple of ndarray
Each array in the tuple has the same shape as the ``indices``
array.

See Also
--------
ravel_multi_index

Examples
--------
>>> np.unravel_index([22, 41, 37], (7,6))
(array([3, 6, 6]), array([4, 5, 1]))
>>> np.unravel_index([31, 41, 13], (7,6), order='F')
(array([3, 6, 6]), array([4, 5, 1]))

>>> np.unravel_index(1621, (6,7,8,9))

(3, 1, 4, 1)

unwrap(p, discont=None, axis=-1, *, period=6.283185307179586)

Unwrap by taking the complement of large deltas with respect to the period.

This unwraps a signal `p` by changing elements which have an absolute

difference from their predecessor of more than ``max(discont, period/2)``
to their `period`-complementary values.

For the default case where `period` is :math:`2\pi` and `discont` is

:math:`\pi`, this unwraps a radian phase `p` such that adjacent differences
are never greater than :math:`\pi` by adding :math:`2k\pi` for some
integer :math:`k`.

Parameters
----------
p : array_like
Input array.
discont : float, optional
Maximum discontinuity between values, default is ``period/2``.
Values below ``period/2`` are treated as if they were ``period/2``.
To have an effect different from the default, `discont` should be
larger than ``period/2``.
axis : int, optional
Axis along which unwrap will operate, default is the last axis.
period : float, optional
Size of the range over which the input wraps. By default, it is
``2 pi``.

.. versionadded:: 1.21.0
 Returns
-------
out : ndarray
Output array.

See Also
--------
rad2deg, deg2rad

Notes
-----
If the discontinuity in `p` is smaller than ``period/2``,
but larger than `discont`, no unwrapping is done because taking
the complement would only make the discontinuity larger.

Examples
--------
>>> phase = np.linspace(0, np.pi, num=5)
>>> phase[3:] += np.pi
>>> phase
array([ 0. , 0.78539816, 1.57079633, 5.49778714, 6.28318531]) #
may vary
>>> np.unwrap(phase)
array([ 0. , 0.78539816, 1.57079633, -0.78539816, 0. ]) #
may vary
>>> np.unwrap([0, 1, 2, -1, 0], period=4)
array([0, 1, 2, 3, 4])
>>> np.unwrap([ 1, 2, 3, 4, 5, 6, 1, 2, 3], period=6)
array([1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> np.unwrap([2, 3, 4, 5, 2, 3, 4, 5], period=4)
array([2, 3, 4, 5, 6, 7, 8, 9])
>>> phase_deg = np.mod(np.linspace(0 ,720, 19), 360) - 180
>>> np.unwrap(phase_deg, period=360)
array([-180., -140., -100., -60., -20., 20., 60., 100., 140.,
180., 220., 260., 300., 340., 380., 420., 460., 500.,
540.])

vander(x, N=None, increasing=False)

Generate a Vandermonde matrix.

The columns of the output matrix are powers of the input vector. The
order of the powers is determined by the `increasing` boolean argument.
Specifically, when `increasing` is False, the `i`-th output column is
the input vector raised element-wise to the power of ``N - i - 1``. Such
a matrix with a geometric progression in each row is named for Alexandre-
Theophile Vandermonde.

Parameters
----------
x : array_like
1-D input array.
N : int, optional
Number of columns in the output. If `N` is not specified, a square
array is returned (``N = len(x)``).
increasing : bool, optional
Order of the powers of the columns. If True, the powers increase
from left to right, if False (the default) they are reversed.

.. versionadded:: 1.9.0
 Returns
-------
out : ndarray
Vandermonde matrix. If `increasing` is False, the first column is
``x^(N-1)``, the second ``x^(N-2)`` and so forth. If `increasing` is
True, the columns are ``x^0, x^1, ..., x^(N-1)``.

See Also
--------
polynomial.polynomial.polyvander

Examples
--------
>>> x = np.array([1, 2, 3, 5])
>>> N = 3
>>> np.vander(x, N)
array([[ 1, 1, 1],
[ 4, 2, 1],
[ 9, 3, 1],
[25, 5, 1]])

>>> np.column_stack([x**(N-1-i) for i in range(N)])

array([[ 1, 1, 1],
[ 4, 2, 1],
[ 9, 3, 1],
[25, 5, 1]])

>>> x = np.array([1, 2, 3, 5])

>>> np.vander(x)
array([[ 1, 1, 1, 1],
[ 8, 4, 2, 1],
[ 27, 9, 3, 1],
[125, 25, 5, 1]])
>>> np.vander(x, increasing=True)
array([[ 1, 1, 1, 1],
[ 1, 2, 4, 8],
[ 1, 3, 9, 27],
[ 1, 5, 25, 125]])

The determinant of a square Vandermonde matrix is the product

of the differences between the values of the input vector:

>>> np.linalg.det(np.vander(x))
48.000000000000043 # may vary
>>> (5-3)*(5-2)*(5-1)*(3-2)*(3-1)*(2-1)
48

var(a, axis=None, dtype=None, out=None, ddof=0, keepdims=<no value>, *,

where=<no value>)
Compute the variance along the specified axis.

Returns the variance of the array elements, a measure of the spread of a

distribution. The variance is computed for the flattened array by
default, otherwise over the specified axis.

Parameters
----------
a : array_like
 Array containing numbers whose variance is desired. If `a` is not an
array, a conversion is attempted.
axis : None or int or tuple of ints, optional
Axis or axes along which the variance is computed. The default is to
compute the variance of the flattened array.

.. versionadded:: 1.7.0

If this is a tuple of ints, a variance is performed over multiple axes,

instead of a single axis or all the axes as before.
dtype : data-type, optional
Type to use in computing the variance. For arrays of integer type
the default is `float64`; for arrays of float types it is the same as
the array type.
out : ndarray, optional
Alternate output array in which to place the result. It must have
the same shape as the expected output, but the type is cast if
necessary.
ddof : int, optional
"Delta Degrees of Freedom": the divisor used in the calculation is
``N - ddof``, where ``N`` represents the number of elements. By
default `ddof` is zero.
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 input array.

If the default value is passed, then `keepdims` will not be

passed through to the `var` method of sub-classes of
`ndarray`, however any non-default value will be. If the
sub-class' method does not implement `keepdims` any
exceptions will be raised.

where : array_like of bool, optional

Elements to include in the variance. See `~numpy.ufunc.reduce` for
details.

.. versionadded:: 1.20.0

Returns
-------
variance : ndarray, see dtype parameter above
If ``out=None``, returns a new array containing the variance;
otherwise, a reference to the output array is returned.

See Also
--------
std, mean, nanmean, nanstd, nanvar
:ref:`ufuncs-output-type`

Notes
-----
The variance is the average of the squared deviations from the mean,
i.e., ``var = mean(x)``, where ``x = abs(a - a.mean())**2``.

The mean is typically calculated as ``x.sum() / N``, where ``N = len(x)``.

If, however, `ddof` is specified, the divisor ``N - ddof`` is used
instead. In standard statistical practice, ``ddof=1`` provides an
unbiased estimator of the variance of a hypothetical infinite population.
 ``ddof=0`` provides a maximum likelihood estimate of the variance for
normally distributed variables.

Note that for complex numbers, the absolute value is taken before
squaring, so that the result is always real and nonnegative.

For floating-point input, the variance is computed using the same

precision the input has. Depending on the input data, this can cause
the results to be inaccurate, especially for `float32` (see example
below). Specifying a higher-accuracy accumulator using the ``dtype``
keyword can alleviate this issue.

Examples
--------
>>> a = np.array([[1, 2], [3, 4]])
>>> np.var(a)
1.25
>>> np.var(a, axis=0)
array([1., 1.])
>>> np.var(a, axis=1)
array([0.25, 0.25])

In single precision, var() can be inaccurate:

>>> a = np.zeros((2, 512*512), dtype=np.float32)

>>> a[0, :] = 1.0
>>> a[1, :] = 0.1
>>> np.var(a)
0.20250003

Computing the variance in float64 is more accurate:

>>> np.var(a, dtype=np.float64)

0.20249999932944759 # may vary
>>> ((1-0.55)**2 + (0.1-0.55)**2)/2
0.2025

Specifying a where argument:

>>> a = np.array([[14, 8, 11, 10], [7, 9, 10, 11], [10, 15, 5, 10]])
>>> np.var(a)
6.833333333333333 # may vary
>>> np.var(a, where=[[True], [True], [False]])
4.0

vdot(...)
vdot(a, b, /)

Return the dot product of two vectors.

The vdot(`a`, `b`) function handles complex numbers differently than

dot(`a`, `b`). If the first argument is complex the complex conjugate
of the first argument is used for the calculation of the dot product.

Note that `vdot` handles multidimensional arrays differently than `dot`:

it does *not* perform a matrix product, but flattens input arguments
to 1-D vectors first. Consequently, it should only be used for vectors.

Parameters
 ----------
a : array_like
If `a` is complex the complex conjugate is taken before calculation
of the dot product.
b : array_like
Second argument to the dot product.

Returns
-------
output : ndarray
Dot product of `a` and `b`. Can be an int, float, or
complex depending on the types of `a` and `b`.

See Also
--------
dot : Return the dot product without using the complex conjugate of the
first argument.

Examples
--------
>>> a = np.array([1+2j,3+4j])
>>> b = np.array([5+6j,7+8j])
>>> np.vdot(a, b)
(70-8j)
>>> np.vdot(b, a)
(70+8j)

Note that higher-dimensional arrays are flattened!

>>> a = np.array([[1, 4], [5, 6]])

>>> b = np.array([[4, 1], [2, 2]])
>>> np.vdot(a, b)
30
>>> np.vdot(b, a)
30
>>> 1*4 + 4*1 + 5*2 + 6*2
30

vsplit(ary, indices_or_sections)
Split an array into multiple sub-arrays vertically (row-wise).

Please refer to the ``split`` documentation. ``vsplit`` is equivalent

to ``split`` with `axis=0` (default), the array is always split along the
first axis regardless of the array dimension.

See Also
--------
split : Split an array into multiple sub-arrays of equal size.

Examples
--------
>>> x = np.arange(16.0).reshape(4, 4)
>>> x
array([[ 0., 1., 2., 3.],
[ 4., 5., 6., 7.],
[ 8., 9., 10., 11.],
[12., 13., 14., 15.]])
>>> np.vsplit(x, 2)
[array([[0., 1., 2., 3.],
 [4., 5., 6., 7.]]), array([[ 8., 9., 10., 11.],
[12., 13., 14., 15.]])]
>>> np.vsplit(x, np.array([3, 6]))
[array([[ 0., 1., 2., 3.],
[ 4., 5., 6., 7.],
[ 8., 9., 10., 11.]]), array([[12., 13., 14., 15.]]), array([],
shape=(0, 4), dtype=float64)]

With a higher dimensional array the split is still along the first axis.

>>> x = np.arange(8.0).reshape(2, 2, 2)
>>> x
array([[[0., 1.],
[2., 3.]],
[[4., 5.],
[6., 7.]]])
>>> np.vsplit(x, 2)
[array([[[0., 1.],
[2., 3.]]]), array([[[4., 5.],
[6., 7.]]])]

vstack(tup, *, dtype=None, casting='same_kind')

Stack arrays in sequence vertically (row wise).

This is equivalent to concatenation along the first axis after 1-D arrays
of shape `(N,)` have been reshaped to `(1,N)`. Rebuilds arrays divided by
`vsplit`.

This function makes most sense for arrays with up to 3 dimensions. For
instance, for pixel-data with a height (first axis), width (second axis),
and r/g/b channels (third axis). The functions `concatenate`, `stack` and
`block` provide more general stacking and concatenation operations.

``np.row_stack`` is an alias for `vstack`. They are the same function.

Parameters
----------
tup : sequence of ndarrays
The arrays must have the same shape along all but the first axis.
1-D arrays must have the same length.

dtype : str or dtype

If provided, the destination array will have this dtype. Cannot be
provided together with `out`.

.. versionadded:: 1.24

casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional

Controls what kind of data casting may occur. Defaults to 'same_kind'.

.. versionadded:: 1.24

Returns
-------
stacked : ndarray
The array formed by stacking the given arrays, will be at least 2-D.

See Also
--------
 concatenate : Join a sequence of arrays along an existing axis.
stack : Join a sequence of arrays along a new axis.
block : Assemble an nd-array from nested lists of blocks.
hstack : Stack arrays in sequence horizontally (column wise).
dstack : Stack arrays in sequence depth wise (along third axis).
column_stack : Stack 1-D arrays as columns into a 2-D array.
vsplit : Split an array into multiple sub-arrays vertically (row-wise).

Examples
--------
>>> a = np.array([1, 2, 3])
>>> b = np.array([4, 5, 6])
>>> np.vstack((a,b))
array([[1, 2, 3],
[4, 5, 6]])

>>> a = np.array([[1], [2], [3]])

>>> b = np.array([[4], [5], [6]])
>>> np.vstack((a,b))
array([[1],
[2],
[3],
[4],
[5],
[6]])

where(...)
where(condition, [x, y], /)

Return elements chosen from `x` or `y` depending on `condition`.

.. note::
When only `condition` is provided, this function is a shorthand for
``np.asarray(condition).nonzero()``. Using `nonzero` directly should be
preferred, as it behaves correctly for subclasses. The rest of this
documentation covers only the case where all three arguments are
provided.

Parameters
----------
condition : array_like, bool
Where True, yield `x`, otherwise yield `y`.
x, y : array_like
Values from which to choose. `x`, `y` and `condition` need to be
broadcastable to some shape.

Returns
-------
out : ndarray
An array with elements from `x` where `condition` is True, and elements
from `y` elsewhere.

See Also
--------
choose
nonzero : The function that is called when x and y are omitted

Notes
-----
 If all the arrays are 1-D, `where` is equivalent to::

[xv if c else yv
for c, xv, yv in zip(condition, x, y)]

Examples
--------
>>> a = np.arange(10)
>>> a
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> np.where(a < 5, a, 10*a)
array([ 0, 1, 2, 3, 4, 50, 60, 70, 80, 90])

This can be used on multidimensional arrays too:

>>> np.where([[True, False], [True, True]],

... [[1, 2], [3, 4]],
... [[9, 8], [7, 6]])
array([[1, 8],
[3, 4]])

The shapes of x, y, and the condition are broadcast together:

>>> x, y = np.ogrid[:3, :4]

>>> np.where(x < y, x, 10 + y) # both x and 10+y are broadcast
array([[10, 0, 0, 0],
[10, 11, 1, 1],
[10, 11, 12, 2]])

>>> a = np.array([[0, 1, 2],

... [0, 2, 4],
... [0, 3, 6]])
>>> np.where(a < 4, a, -1) # -1 is broadcast
array([[ 0, 1, 2],
[ 0, 2, -1],
[ 0, 3, -1]])

who(vardict=None)
Print the NumPy arrays in the given dictionary.

If there is no dictionary passed in or `vardict` is None then returns

NumPy arrays in the globals() dictionary (all NumPy arrays in the
namespace).

Parameters
----------
vardict : dict, optional
A dictionary possibly containing ndarrays. Default is globals().

Returns
-------
out : None
Returns 'None'.

Notes
-----
Prints out the name, shape, bytes and type of all of the ndarrays
present in `vardict`.
 Examples
--------
>>> a = np.arange(10)
>>> b = np.ones(20)
>>> np.who()
Name Shape Bytes Type
===========================================================
a 10 80 int64
b 20 160 float64
Upper bound on total bytes = 240

>>> d = {'x': np.arange(2.0), 'y': np.arange(3.0), 'txt': 'Some str',

... 'idx':5}
>>> np.who(d)
Name Shape Bytes Type
===========================================================
x 2 16 float64
y 3 24 float64
Upper bound on total bytes = 40

zeros(...)
zeros(shape, dtype=float, order='C', *, like=None)

Return a new array of given shape and type, filled with zeros.

Parameters
----------
shape : int or tuple of ints
Shape of the new array, e.g., ``(2, 3)`` or ``2``.
dtype : data-type, optional
The desired data-type for the array, e.g., `numpy.int8`. Default is
`numpy.float64`.
order : {'C', 'F'}, optional, default: 'C'
Whether to store multi-dimensional data in row-major
(C-style) or column-major (Fortran-style) order in
memory.
like : array_like, optional
Reference object to allow the creation of arrays which are not
NumPy arrays. If an array-like passed in as ``like`` supports
the ``__array_function__`` protocol, the result will be defined
by it. In this case, it ensures the creation of an array object
compatible with that passed in via this argument.

.. versionadded:: 1.20.0

Returns
-------
out : ndarray
Array of zeros with the given shape, dtype, and order.

See Also
--------
zeros_like : Return an array of zeros with shape and type of input.
empty : Return a new uninitialized array.
ones : Return a new array setting values to one.
full : Return a new array of given shape filled with value.

Examples
--------
 >>> np.zeros(5)
array([ 0., 0., 0., 0., 0.])

>>> np.zeros((5,), dtype=int)

array([0, 0, 0, 0, 0])

>>> np.zeros((2, 1))

array([[ 0.],
[ 0.]])

>>> s = (2,2)
>>> np.zeros(s)
array([[ 0., 0.],
[ 0., 0.]])

>>> np.zeros((2,), dtype=[('x', 'i4'), ('y', 'i4')]) # custom dtype

array([(0, 0), (0, 0)],
dtype=[('x', '<i4'), ('y', '<i4')])

zeros_like(a, dtype=None, order='K', subok=True, shape=None)

Return an array of zeros with the same shape and type as a given array.

Parameters
----------
a : array_like
The shape and data-type of `a` define these same attributes of
the returned array.
dtype : data-type, optional
Overrides the data type of the result.

.. versionadded:: 1.6.0
order : {'C', 'F', 'A', or 'K'}, optional
Overrides the memory layout of the result. '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.

.. versionadded:: 1.6.0
subok : bool, optional.
If True, then the newly created array will use the sub-class
type of `a`, otherwise it will be a base-class array. Defaults
to True.
shape : int or sequence of ints, optional.
Overrides the shape of the result. If order='K' and the number of
dimensions is unchanged, will try to keep order, otherwise,
order='C' is implied.

.. versionadded:: 1.17.0

Returns
-------
out : ndarray
Array of zeros with the same shape and type as `a`.

See Also
--------
empty_like : Return an empty array with shape and type of input.
ones_like : Return an array of ones with shape and type of input.
full_like : Return a new array with shape of input filled with value.
 zeros : Return a new array setting values to zero.

Examples
--------
>>> x = np.arange(6)
>>> x = x.reshape((2, 3))
>>> x
array([[0, 1, 2],
[3, 4, 5]])
>>> np.zeros_like(x)
array([[0, 0, 0],
[0, 0, 0]])

>>> y = np.arange(3, dtype=float)

>>> y
array([0., 1., 2.])
>>> np.zeros_like(y)
array([0., 0., 0.])

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>
__NUMPY_SETUP__ = False
 __all__ = ['exceptions', 'ModuleDeprecationWarning', 'VisibleDeprecati...
__deprecated_attrs__ = {'bool8': (<class 'numpy.bool_'>, '`np.bool8` i...
__expired_functions__ = {'fv': 'In accordance with NEP 32, the functio...
__former_attrs__ = {'bool': "module 'numpy' has no attribute 'bool'.\n...
__future_scalars__ = {'bool', 'bytes', 'long', 'object', 'str', 'ulong...
absolute = <ufunc 'absolute'>
absolute(x, /, out=None, *, where=True, casting='same_kind', order='K',
dtype=None, subok=True[, signature, extobj])

Calculate the absolute value element-wise.

``np.abs`` is a shorthand for this function.

Parameters
----------
x : array_like
Input array.
out : ndarray, None, or tuple of ndarray and None, optional
A location into which the result is stored. If provided, it must have
a shape that the inputs broadcast to. If not provided or None,
a freshly-allocated array is returned. A tuple (possible only as a
keyword argument) must have length equal to the number of outputs.
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
-------
absolute : ndarray
An ndarray containing the absolute value of
each element in `x`. For complex input, ``a + ib``, the
absolute value is :math:`\sqrt{ a^2 + b^2 }`.
This is a scalar if `x` is a scalar.

Examples
--------
>>> x = np.array([-1.2, 1.2])
>>> np.absolute(x)
array([ 1.2, 1.2])
>>> np.absolute(1.2 + 1j)
1.5620499351813308

Plot the function over ``[-10, 10]``:

>>> import matplotlib.pyplot as plt

>>> x = np.linspace(start=-10, stop=10, num=101)

>>> plt.plot(x, np.absolute(x))
>>> plt.show()

Plot the function over the complex plane:

 >>> xx = x + 1j * x[:, np.newaxis]
>>> plt.imshow(np.abs(xx), extent=[-10, 10, -10, 10], cmap='gray')
>>> plt.show()

The `abs` function can be used as a shorthand for ``np.absolute`` on

ndarrays.

>>> x = np.array([-1.2, 1.2])

>>> abs(x)
array([1.2, 1.2])

add = <ufunc 'add'>

add(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K',
dtype=None, subok=True[, signature, extobj])

Add arguments element-wise.

Parameters
----------
x1, x2 : array_like
The arrays to be added.
If ``x1.shape != x2.shape``, they must be broadcastable to a common
shape (which becomes the shape of the output).
out : ndarray, None, or tuple of ndarray and None, optional
A location into which the result is stored. If provided, it must have
a shape that the inputs broadcast to. If not provided or None,
a freshly-allocated array is returned. A tuple (possible only as a
keyword argument) must have length equal to the number of outputs.
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
-------
add : ndarray or scalar
The sum of `x1` and `x2`, element-wise.
This is a scalar if both `x1` and `x2` are scalars.

Notes
-----
Equivalent to `x1` + `x2` in terms of array broadcasting.

Examples
--------
>>> np.add(1.0, 4.0)
5.0
>>> x1 = np.arange(9.0).reshape((3, 3))
>>> x2 = np.arange(3.0)
>>> np.add(x1, x2)
array([[ 0., 2., 4.],
[ 3., 5., 7.],
[ 6., 8., 10.]])
 The ``+`` operator can be used as a shorthand for ``np.add`` on ndarrays.

>>> x1 = np.arange(9.0).reshape((3, 3))

>>> x2 = np.arange(3.0)
>>> x1 + x2
array([[ 0., 2., 4.],
[ 3., 5., 7.],
[ 6., 8., 10.]])

arccos = <ufunc 'arccos'>

arccos(x, /, out=None, *, where=True, casting='same_kind', order='K',
dtype=None, subok=True[, signature, extobj])

Trigonometric inverse cosine, element-wise.

The inverse of `cos` so that, if ``y = cos(x)``, then ``x = arccos(y)``.

Parameters
----------
x : array_like
`x`-coordinate on the unit circle.
For real arguments, the domain is [-1, 1].
out : ndarray, None, or tuple of ndarray and None, optional
A location into which the result is stored. If provided, it must have
a shape that the inputs broadcast to. If not provided or None,
a freshly-allocated array is returned. A tuple (possible only as a
keyword argument) must have length equal to the number of outputs.
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
-------
angle : ndarray
The angle of the ray intersecting the unit circle at the given
`x`-coordinate in radians [0, pi].
This is a scalar if `x` is a scalar.

See Also
--------
cos, arctan, arcsin, emath.arccos

Notes
-----
`arccos` is a multivalued function: for each `x` there are infinitely
many numbers `z` such that ``cos(z) = x``. The convention is to return
the angle `z` whose real part lies in `[0, pi]`.

For real-valued input data types, `arccos` always returns real output.
For each value that cannot be expressed as a real number or infinity,
it yields ``nan`` and sets the `invalid` floating point error flag.
 For complex-valued input, `arccos` is a complex analytic function that
has branch cuts ``[-inf, -1]`` and `[1, inf]` and is continuous from
above on the former and from below on the latter.

The inverse `cos` is also known as `acos` or cos^-1.

References
----------
M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions",
10th printing, 1964, pp. 79.
https://personal.math.ubc.ca/~cbm/aands/page_79.htm

Examples
--------
We expect the arccos of 1 to be 0, and of -1 to be pi:

>>> np.arccos([1, -1])

array([ 0. , 3.14159265])

Plot arccos:

>>> import matplotlib.pyplot as plt

>>> x = np.linspace(-1, 1, num=100)
>>> plt.plot(x, np.arccos(x))
>>> plt.axis('tight')
>>> plt.show()

arccosh = <ufunc 'arccosh'>

arccosh(x, /, out=None, *, where=True, casting='same_kind', order='K',
dtype=None, subok=True[, signature, extobj])

Inverse hyperbolic cosine, element-wise.

Parameters
----------
x : array_like
Input array.
out : ndarray, None, or tuple of ndarray and None, optional
A location into which the result is stored. If provided, it must have
a shape that the inputs broadcast to. If not provided or None,
a freshly-allocated array is returned. A tuple (possible only as a
keyword argument) must have length equal to the number of outputs.
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
-------
arccosh : ndarray
Array of the same shape as `x`.
This is a scalar if `x` is a scalar.
 See Also
--------

cosh, arcsinh, sinh, arctanh, tanh

Notes
-----
`arccosh` is a multivalued function: for each `x` there are infinitely
many numbers `z` such that `cosh(z) = x`. The convention is to return the
`z` whose imaginary part lies in ``[-pi, pi]`` and the real part in
``[0, inf]``.

For real-valued input data types, `arccosh` always returns real output.
For each value that cannot be expressed as a real number or infinity, it
yields ``nan`` and sets the `invalid` floating point error flag.

For complex-valued input, `arccosh` is a complex analytical function that

has a branch cut `[-inf, 1]` and is continuous from above on it.

References
----------
.. [1] M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions",
10th printing, 1964, pp. 86.
https://personal.math.ubc.ca/~cbm/aands/page_86.htm
.. [2] Wikipedia, "Inverse hyperbolic function",
https://en.wikipedia.org/wiki/Arccosh

Examples
--------
>>> np.arccosh([np.e, 10.0])
array([ 1.65745445, 2.99322285])
>>> np.arccosh(1)
0.0

arcsin = <ufunc 'arcsin'>

arcsin(x, /, out=None, *, where=True, casting='same_kind', order='K',
dtype=None, subok=True[, signature, extobj])

Inverse sine, element-wise.

Parameters
----------
x : array_like
`y`-coordinate on the unit circle.
out : ndarray, None, or tuple of ndarray and None, optional
A location into which the result is stored. If provided, it must have
a shape that the inputs broadcast to. If not provided or None,
a freshly-allocated array is returned. A tuple (possible only as a
keyword argument) must have length equal to the number of outputs.
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
-------
angle : ndarray
The inverse sine of each element in `x`, in radians and in the
closed interval ``[-pi/2, pi/2]``.
This is a scalar if `x` is a scalar.

See Also
--------
sin, cos, arccos, tan, arctan, arctan2, emath.arcsin

Notes
-----
`arcsin` is a multivalued function: for each `x` there are infinitely
many numbers `z` such that :math:`sin(z) = x`. The convention is to
return the angle `z` whose real part lies in [-pi/2, pi/2].

For real-valued input data types, *arcsin* always returns real output.
For each value that cannot be expressed as a real number or infinity,
it yields ``nan`` and sets the `invalid` floating point error flag.

For complex-valued input, `arcsin` is a complex analytic function that

has, by convention, the branch cuts [-inf, -1] and [1, inf] and is
continuous from above on the former and from below on the latter.

The inverse sine is also known as `asin` or sin^{-1}.

References
----------
Abramowitz, M. and Stegun, I. A., *Handbook of Mathematical Functions*,
10th printing, New York: Dover, 1964, pp. 79ff.
https://personal.math.ubc.ca/~cbm/aands/page_79.htm

Examples
--------
>>> np.arcsin(1) # pi/2
1.5707963267948966
>>> np.arcsin(-1) # -pi/2
-1.5707963267948966
>>> np.arcsin(0)
0.0

arcsinh = <ufunc 'arcsinh'>

arcsinh(x, /, out=None, *, where=True, casting='same_kind', order='K',
dtype=None, subok=True[, signature, extobj])

Inverse hyperbolic sine element-wise.

Parameters
----------
x : array_like
Input array.
out : ndarray, None, or tuple of ndarray and None, optional
A location into which the result is stored. If provided, it must have
a shape that the inputs broadcast to. If not provided or None,
a freshly-allocated array is returned. A tuple (possible only as a
keyword argument) must have length equal to the number of outputs.
 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
-------
out : ndarray or scalar
Array of the same shape as `x`.
This is a scalar if `x` is a scalar.

Notes
-----
`arcsinh` is a multivalued function: for each `x` there are infinitely
many numbers `z` such that `sinh(z) = x`. The convention is to return the
`z` whose imaginary part lies in `[-pi/2, pi/2]`.

For real-valued input data types, `arcsinh` always returns real output.
For each value that cannot be expressed as a real number or infinity, it
returns ``nan`` and sets the `invalid` floating point error flag.

For complex-valued input, `arccos` is a complex analytical function that

has branch cuts `[1j, infj]` and `[-1j, -infj]` and is continuous from
the right on the former and from the left on the latter.

The inverse hyperbolic sine is also known as `asinh` or ``sinh^-1``.

References
----------
.. [1] M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions",
10th printing, 1964, pp. 86.
https://personal.math.ubc.ca/~cbm/aands/page_86.htm
.. [2] Wikipedia, "Inverse hyperbolic function",
https://en.wikipedia.org/wiki/Arcsinh

Examples
--------
>>> np.arcsinh(np.array([np.e, 10.0]))
array([ 1.72538256, 2.99822295])

arctan = <ufunc 'arctan'>

arctan(x, /, out=None, *, where=True, casting='same_kind', order='K',
dtype=None, subok=True[, signature, extobj])

Trigonometric inverse tangent, element-wise.

The inverse of tan, so that if ``y = tan(x)`` then ``x = arctan(y)``.

Parameters
----------
x : array_like
out : ndarray, None, or tuple of ndarray and None, optional
A location into which the result is stored. If provided, it must have
 a shape that the inputs broadcast to. If not provided or None,
a freshly-allocated array is returned. A tuple (possible only as a
keyword argument) must have length equal to the number of outputs.
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
-------
out : ndarray or scalar
Out has the same shape as `x`. Its real part is in
``[-pi/2, pi/2]`` (``arctan(+/-inf)`` returns ``+/-pi/2``).
This is a scalar if `x` is a scalar.

See Also
--------
arctan2 : The "four quadrant" arctan of the angle formed by (`x`, `y`)
and the positive `x`-axis.
angle : Argument of complex values.

Notes
-----
`arctan` is a multi-valued function: for each `x` there are infinitely
many numbers `z` such that tan(`z`) = `x`. The convention is to return
the angle `z` whose real part lies in [-pi/2, pi/2].

For real-valued input data types, `arctan` always returns real output.
For each value that cannot be expressed as a real number or infinity,
it yields ``nan`` and sets the `invalid` floating point error flag.

For complex-valued input, `arctan` is a complex analytic function that

has [``1j, infj``] and [``-1j, -infj``] as branch cuts, and is continuous
from the left on the former and from the right on the latter.

The inverse tangent is also known as `atan` or tan^{-1}.

References
----------
Abramowitz, M. and Stegun, I. A., *Handbook of Mathematical Functions*,
10th printing, New York: Dover, 1964, pp. 79.
https://personal.math.ubc.ca/~cbm/aands/page_79.htm

Examples
--------
We expect the arctan of 0 to be 0, and of 1 to be pi/4:

>>> np.arctan([0, 1])

array([ 0. , 0.78539816])

>>> np.pi/4
0.78539816339744828
 Plot arctan:

>>> import matplotlib.pyplot as plt

>>> x = np.linspace(-10, 10)
>>> plt.plot(x, np.arctan(x))
>>> plt.axis('tight')
>>> plt.show()

arctan2 = <ufunc 'arctan2'>

arctan2(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K',
dtype=None, subok=True[, signature, extobj])

Element-wise arc tangent of ``x1/x2`` choosing the quadrant correctly.

The quadrant (i.e., branch) is chosen so that ``arctan2(x1, x2)`` is

the signed angle in radians between the ray ending at the origin and
passing through the point (1,0), and the ray ending at the origin and
passing through the point (`x2`, `x1`). (Note the role reversal: the
"`y`-coordinate" is the first function parameter, the "`x`-coordinate"
is the second.) By IEEE convention, this function is defined for
`x2` = +/-0 and for either or both of `x1` and `x2` = +/-inf (see
Notes for specific values).

This function is not defined for complex-valued arguments; for the

so-called argument of complex values, use `angle`.

Parameters
----------
x1 : array_like, real-valued
`y`-coordinates.
x2 : array_like, real-valued
`x`-coordinates.
If ``x1.shape != x2.shape``, they must be broadcastable to a common
shape (which becomes the shape of the output).
out : ndarray, None, or tuple of ndarray and None, optional
A location into which the result is stored. If provided, it must have
a shape that the inputs broadcast to. If not provided or None,
a freshly-allocated array is returned. A tuple (possible only as a
keyword argument) must have length equal to the number of outputs.
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
-------
angle : ndarray
Array of angles in radians, in the range ``[-pi, pi]``.
This is a scalar if both `x1` and `x2` are scalars.

See Also
--------
arctan, tan, angle
 Notes
-----
*arctan2* is identical to the `atan2` function of the underlying
C library. The following special values are defined in the C
standard: [1]_

====== ====== ================

`x1` `x2` `arctan2(x1,x2)`
====== ====== ================
+/- 0 +0 +/- 0
+/- 0 -0 +/- pi
> 0 +/-inf +0 / +pi
< 0 +/-inf -0 / -pi
+/-inf +inf +/- (pi/4)
+/-inf -inf +/- (3*pi/4)
====== ====== ================

Note that +0 and -0 are distinct floating point numbers, as are +inf
and -inf.

References
----------
.. [1] ISO/IEC standard 9899:1999, "Programming language C."

Examples
--------
Consider four points in different quadrants:

>>> x = np.array([-1, +1, +1, -1])

>>> y = np.array([-1, -1, +1, +1])
>>> np.arctan2(y, x) * 180 / np.pi
array([-135., -45., 45., 135.])

Note the order of the parameters. `arctan2` is defined also when `x2` = 0
and at several other special points, obtaining values in
the range ``[-pi, pi]``:

>>> np.arctan2([1., -1.], [0., 0.])

array([ 1.57079633, -1.57079633])
>>> np.arctan2([0., 0., np.inf], [+0., -0., np.inf])
array([0. , 3.14159265, 0.78539816])

arctanh = <ufunc 'arctanh'>

arctanh(x, /, out=None, *, where=True, casting='same_kind', order='K',
dtype=None, subok=True[, signature, extobj])

Inverse hyperbolic tangent element-wise.

Parameters
----------
x : array_like
Input array.
out : ndarray, None, or tuple of ndarray and None, optional
A location into which the result is stored. If provided, it must have
a shape that the inputs broadcast to. If not provided or None,
a freshly-allocated array is returned. A tuple (possible only as a
keyword argument) must have length equal to the number of outputs.
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
-------
out : ndarray or scalar
Array of the same shape as `x`.
This is a scalar if `x` is a scalar.

See Also
--------
emath.arctanh

Notes
-----
`arctanh` is a multivalued function: for each `x` there are infinitely
many numbers `z` such that ``tanh(z) = x``. The convention is to return
the `z` whose imaginary part lies in `[-pi/2, pi/2]`.

For real-valued input data types, `arctanh` always returns real output.
For each value that cannot be expressed as a real number or infinity,
it yields ``nan`` and sets the `invalid` floating point error flag.

For complex-valued input, `arctanh` is a complex analytical function

that has branch cuts `[-1, -inf]` and `[1, inf]` and is continuous from
above on the former and from below on the latter.

The inverse hyperbolic tangent is also known as `atanh` or ``tanh^-1``.

References
----------
.. [1] M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions",
10th printing, 1964, pp. 86.
https://personal.math.ubc.ca/~cbm/aands/page_86.htm
.. [2] Wikipedia, "Inverse hyperbolic function",
https://en.wikipedia.org/wiki/Arctanh

Examples
--------
>>> np.arctanh([0, -0.5])
array([ 0. , -0.54930614])

bitwise_and = <ufunc 'bitwise_and'>

bitwise_and(x1, x2, /, out=None, *, where=True, casting='same_kind',
order='K', dtype=None, subok=True[, signature, extobj])

Compute the bit-wise AND of two arrays element-wise.

Computes the bit-wise AND of the underlying binary representation of

the integers in the input arrays. This ufunc implements the C/Python
operator ``&``.
Parameters
----------
x1, x2 : array_like
Only integer and boolean types are handled.
If ``x1.shape != x2.shape``, they must be broadcastable to a common
shape (which becomes the shape of the output).
out : ndarray, None, or tuple of ndarray and None, optional
A location into which the result is stored. If provided, it must have
a shape that the inputs broadcast to. If not provided or None,
a freshly-allocated array is returned. A tuple (possible only as a
keyword argument) must have length equal to the number of outputs.
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
-------
out : ndarray or scalar
Result.
This is a scalar if both `x1` and `x2` are scalars.

See Also
--------
logical_and
bitwise_or
bitwise_xor
binary_repr :
Return the binary representation of the input number as a string.

Examples
--------
The number 13 is represented by ``00001101``. Likewise, 17 is
represented by ``00010001``. The bit-wise AND of 13 and 17 is
therefore ``000000001``, or 1:

>>> np.bitwise_and(13, 17)

1

>>> np.bitwise_and(14, 13)

12
>>> np.binary_repr(12)
'1100'
>>> np.bitwise_and([14,3], 13)
array([12, 1])

>>> np.bitwise_and([11,7], [4,25])

array([0, 1])
>>> np.bitwise_and(np.array([2,5,255]), np.array([3,14,16]))
array([ 2, 4, 16])
>>> np.bitwise_and([True, True], [False, True])
array([False, True])
 The ``&`` operator can be used as a shorthand for ``np.bitwise_and`` on
ndarrays.

>>> x1 = np.array([2, 5, 255])

>>> x2 = np.array([3, 14, 16])
>>> x1 & x2
array([ 2, 4, 16])

bitwise_not = <ufunc 'invert'>

invert(x, /, out=None, *, where=True, casting='same_kind', order='K',
dtype=None, subok=True[, signature, extobj])

Compute bit-wise inversion, or bit-wise NOT, element-wise.

Computes the bit-wise NOT of the underlying binary representation of

the integers in the input arrays. This ufunc implements the C/Python
operator ``~``.

For signed integer inputs, the two's complement is returned. In a

two's-complement system negative numbers are represented by the two's
complement of the absolute value. This is the most common method of
representing signed integers on computers [1]_. A N-bit
two's-complement system can represent every integer in the range
:math:`-2^{N-1}` to :math:`+2^{N-1}-1`.

Parameters
----------
x : array_like
Only integer and boolean types are handled.
out : ndarray, None, or tuple of ndarray and None, optional
A location into which the result is stored. If provided, it must have
a shape that the inputs broadcast to. If not provided or None,
a freshly-allocated array is returned. A tuple (possible only as a
keyword argument) must have length equal to the number of outputs.
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
-------
out : ndarray or scalar
Result.
This is a scalar if `x` is a scalar.

See Also
--------
bitwise_and, bitwise_or, bitwise_xor
logical_not
binary_repr :
Return the binary representation of the input number as a string.

Notes
 -----
`bitwise_not` is an alias for `invert`:

>>> np.bitwise_not is np.invert

True

References
----------
.. [1] Wikipedia, "Two's complement",
https://en.wikipedia.org/wiki/Two's_complement

Examples
--------
We've seen that 13 is represented by ``00001101``.
The invert or bit-wise NOT of 13 is then:

>>> x = np.invert(np.array(13, dtype=np.uint8))

>>> x
242
>>> np.binary_repr(x, width=8)
'11110010'

The result depends on the bit-width:

>>> x = np.invert(np.array(13, dtype=np.uint16))

>>> x
65522
>>> np.binary_repr(x, width=16)
'1111111111110010'

When using signed integer types the result is the two's complement of
the result for the unsigned type:

>>> np.invert(np.array([13], dtype=np.int8))

array([-14], dtype=int8)
>>> np.binary_repr(-14, width=8)
'11110010'

Booleans are accepted as well:

>>> np.invert(np.array([True, False]))

array([False, True])

The ``~`` operator can be used as a shorthand for ``np.invert`` on

ndarrays.

>>> x1 = np.array([True, False])

>>> ~x1
array([False, True])

bitwise_or = <ufunc 'bitwise_or'>

bitwise_or(x1, x2, /, out=None, *, where=True, casting='same_kind',
order='K', dtype=None, subok=True[, signature, extobj])

Compute the bit-wise OR of two arrays element-wise.

Computes the bit-wise OR of the underlying binary representation of

the integers in the input arrays. This ufunc implements the C/Python
operator ``|``.
Parameters
----------
x1, x2 : array_like
Only integer and boolean types are handled.
If ``x1.shape != x2.shape``, they must be broadcastable to a common
shape (which becomes the shape of the output).
out : ndarray, None, or tuple of ndarray and None, optional
A location into which the result is stored. If provided, it must have
a shape that the inputs broadcast to. If not provided or None,
a freshly-allocated array is returned. A tuple (possible only as a
keyword argument) must have length equal to the number of outputs.
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
-------
out : ndarray or scalar
Result.
This is a scalar if both `x1` and `x2` are scalars.

See Also
--------
logical_or
bitwise_and
bitwise_xor
binary_repr :
Return the binary representation of the input number as a string.

Examples
--------
The number 13 has the binary representation ``00001101``. Likewise,
16 is represented by ``00010000``. The bit-wise OR of 13 and 16 is
then ``00011101``, or 29:

>>> np.bitwise_or(13, 16)

29
>>> np.binary_repr(29)
'11101'

>>> np.bitwise_or(32, 2)
34
>>> np.bitwise_or([33, 4], 1)
array([33, 5])
>>> np.bitwise_or([33, 4], [1, 2])
array([33, 6])

>>> np.bitwise_or(np.array([2, 5, 255]), np.array([4, 4, 4]))

array([ 6, 5, 255])
>>> np.array([2, 5, 255]) | np.array([4, 4, 4])
array([ 6, 5, 255])
 >>> np.bitwise_or(np.array([2, 5, 255, 2147483647], dtype=np.int32),
... np.array([4, 4, 4, 2147483647], dtype=np.int32))
array([ 6, 5, 255, 2147483647])
>>> np.bitwise_or([True, True], [False, True])
array([ True, True])

The ``|`` operator can be used as a shorthand for ``np.bitwise_or`` on

ndarrays.

>>> x1 = np.array([2, 5, 255])

>>> x2 = np.array([4, 4, 4])
>>> x1 | x2
array([ 6, 5, 255])

bitwise_xor = <ufunc 'bitwise_xor'>

bitwise_xor(x1, x2, /, out=None, *, where=True, casting='same_kind',
order='K', dtype=None, subok=True[, signature, extobj])

Compute the bit-wise XOR of two arrays element-wise.

Computes the bit-wise XOR of the underlying binary representation of

the integers in the input arrays. This ufunc implements the C/Python
operator ``^``.

Parameters
----------
x1, x2 : array_like
Only integer and boolean types are handled.
If ``x1.shape != x2.shape``, they must be broadcastable to a common
shape (which becomes the shape of the output).
out : ndarray, None, or tuple of ndarray and None, optional
A location into which the result is stored. If provided, it must have
a shape that the inputs broadcast to. If not provided or None,
a freshly-allocated array is returned. A tuple (possible only as a
keyword argument) must have length equal to the number of outputs.
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
-------
out : ndarray or scalar
Result.
This is a scalar if both `x1` and `x2` are scalars.

See Also
--------
logical_xor
bitwise_and
bitwise_or
binary_repr :
Return the binary representation of the input number as a string.
 Examples
--------
The number 13 is represented by ``00001101``. Likewise, 17 is
represented by ``00010001``. The bit-wise XOR of 13 and 17 is
therefore ``00011100``, or 28:

>>> np.bitwise_xor(13, 17)

28
>>> np.binary_repr(28)
'11100'

>>> np.bitwise_xor(31, 5)
26
>>> np.bitwise_xor([31,3], 5)
array([26, 6])

>>> np.bitwise_xor([31,3], [5,6])

array([26, 5])
>>> np.bitwise_xor([True, True], [False, True])
array([ True, False])

The ``^`` operator can be used as a shorthand for ``np.bitwise_xor`` on

ndarrays.

>>> x1 = np.array([True, True])

>>> x2 = np.array([False, True])
>>> x1 ^ x2
array([ True, False])

c_ = <numpy.lib.index_tricks.CClass object>
cast = {<class 'numpy.int32'>: <function <lambda> at 0x...t16'>: <func...
cbrt = <ufunc 'cbrt'>
cbrt(x, /, out=None, *, where=True, casting='same_kind', order='K',
dtype=None, subok=True[, signature, extobj])

Return the cube-root of an array, element-wise.

.. versionadded:: 1.10.0

Parameters
----------
x : array_like
The values whose cube-roots are required.
out : ndarray, None, or tuple of ndarray and None, optional
A location into which the result is stored. If provided, it must have
a shape that the inputs broadcast to. If not provided or None,
a freshly-allocated array is returned. A tuple (possible only as a
keyword argument) must have length equal to the number of outputs.
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
-------
y : ndarray
An array of the same shape as `x`, containing the cube
cube-root of each element in `x`.
If `out` was provided, `y` is a reference to it.
This is a scalar if `x` is a scalar.

Examples
--------
>>> np.cbrt([1,8,27])
array([ 1., 2., 3.])

ceil = <ufunc 'ceil'>

ceil(x, /, out=None, *, where=True, casting='same_kind', order='K',
dtype=None, subok=True[, signature, extobj])

Return the ceiling of the input, element-wise.

The ceil of the scalar `x` is the smallest integer `i`, such that
``i >= x``. It is often denoted as :math:`\lceil x \rceil`.

Parameters
----------
x : array_like
Input data.
out : ndarray, None, or tuple of ndarray and None, optional
A location into which the result is stored. If provided, it must have
a shape that the inputs broadcast to. If not provided or None,
a freshly-allocated array is returned. A tuple (possible only as a
keyword argument) must have length equal to the number of outputs.
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
-------
y : ndarray or scalar
The ceiling of each element in `x`, with `float` dtype.
This is a scalar if `x` is a scalar.

See Also
--------
floor, trunc, rint, fix

Examples
--------
>>> a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0])
>>> np.ceil(a)
array([-1., -1., -0., 1., 2., 2., 2.])
 conj = <ufunc 'conjugate'>
conjugate(x, /, out=None, *, where=True, casting='same_kind', order='K',
dtype=None, subok=True[, signature, extobj])

Return the complex conjugate, element-wise.

The complex conjugate of a complex number is obtained by changing the

sign of its imaginary part.

Parameters
----------
x : array_like
Input value.
out : ndarray, None, or tuple of ndarray and None, optional
A location into which the result is stored. If provided, it must have
a shape that the inputs broadcast to. If not provided or None,
a freshly-allocated array is returned. A tuple (possible only as a
keyword argument) must have length equal to the number of outputs.
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
-------
y : ndarray
The complex conjugate of `x`, with same dtype as `y`.
This is a scalar if `x` is a scalar.

Notes
-----
`conj` is an alias for `conjugate`:

>>> np.conj is np.conjugate

True

Examples
--------
>>> np.conjugate(1+2j)
(1-2j)

>>> x = np.eye(2) + 1j * np.eye(2)

>>> np.conjugate(x)
array([[ 1.-1.j, 0.-0.j],
[ 0.-0.j, 1.-1.j]])

conjugate = <ufunc 'conjugate'>

conjugate(x, /, out=None, *, where=True, casting='same_kind', order='K',
dtype=None, subok=True[, signature, extobj])

Return the complex conjugate, element-wise.

 The complex conjugate of a complex number is obtained by changing the
sign of its imaginary part.

Parameters
----------
x : array_like
Input value.
out : ndarray, None, or tuple of ndarray and None, optional
A location into which the result is stored. If provided, it must have
a shape that the inputs broadcast to. If not provided or None,
a freshly-allocated array is returned. A tuple (possible only as a
keyword argument) must have length equal to the number of outputs.
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
-------
y : ndarray
The complex conjugate of `x`, with same dtype as `y`.
This is a scalar if `x` is a scalar.

Notes
-----
`conj` is an alias for `conjugate`:

>>> np.conj is np.conjugate

True

Examples
--------
>>> np.conjugate(1+2j)
(1-2j)

>>> x = np.eye(2) + 1j * np.eye(2)

>>> np.conjugate(x)
array([[ 1.-1.j, 0.-0.j],
[ 0.-0.j, 1.-1.j]])

copysign = <ufunc 'copysign'>

copysign(x1, x2, /, out=None, *, where=True, casting='same_kind',
order='K', dtype=None, subok=True[, signature, extobj])

Change the sign of x1 to that of x2, element-wise.

If `x2` is a scalar, its sign will be copied to all elements of `x1`.

Parameters
----------
x1 : array_like
Values to change the sign of.
x2 : array_like
 The sign of `x2` is copied to `x1`.
If ``x1.shape != x2.shape``, they must be broadcastable to a common
shape (which becomes the shape of the output).
out : ndarray, None, or tuple of ndarray and None, optional
A location into which the result is stored. If provided, it must have
a shape that the inputs broadcast to. If not provided or None,
a freshly-allocated array is returned. A tuple (possible only as a
keyword argument) must have length equal to the number of outputs.
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
-------
out : ndarray or scalar
The values of `x1` with the sign of `x2`.
This is a scalar if both `x1` and `x2` are scalars.

Examples
--------
>>> np.copysign(1.3, -1)
-1.3
>>> 1/np.copysign(0, 1)
inf
>>> 1/np.copysign(0, -1)
-inf

>>> np.copysign([-1, 0, 1], -1.1)

array([-1., -0., -1.])
>>> np.copysign([-1, 0, 1], np.arange(3)-1)
array([-1., 0., 1.])

cos = <ufunc 'cos'>

cos(x, /, out=None, *, where=True, casting='same_kind', order='K',
dtype=None, subok=True[, signature, extobj])

Cosine element-wise.

Parameters
----------
x : array_like
Input array in radians.
out : ndarray, None, or tuple of ndarray and None, optional
A location into which the result is stored. If provided, it must have
a shape that the inputs broadcast to. If not provided or None,
a freshly-allocated array is returned. A tuple (possible only as a
keyword argument) must have length equal to the number of outputs.
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
-------
y : ndarray
The corresponding cosine values.
This is a scalar if `x` is a scalar.

Notes
-----
If `out` is provided, the function writes the result into it,
and returns a reference to `out`. (See Examples)

References
----------
M. Abramowitz and I. A. Stegun, Handbook of Mathematical Functions.
New York, NY: Dover, 1972.

Examples
--------
>>> np.cos(np.array([0, np.pi/2, np.pi]))
array([ 1.00000000e+00, 6.12303177e-17, -1.00000000e+00])
>>>
>>> # Example of providing the optional output parameter
>>> out1 = np.array([0], dtype='d')
>>> out2 = np.cos([0.1], out1)
>>> out2 is out1
True
>>>
>>> # Example of ValueError due to provision of shape mis-matched `out`
>>> np.cos(np.zeros((3,3)),np.zeros((2,2)))
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: operands could not be broadcast together with shapes (3,3)
(2,2)

cosh = <ufunc 'cosh'>

cosh(x, /, out=None, *, where=True, casting='same_kind', order='K',
dtype=None, subok=True[, signature, extobj])

Hyperbolic cosine, element-wise.

Equivalent to ``1/2 * (np.exp(x) + np.exp(-x))`` and ``np.cos(1j*x)``.

Parameters
----------
x : array_like
Input array.
out : ndarray, None, or tuple of ndarray and None, optional
A location into which the result is stored. If provided, it must have
a shape that the inputs broadcast to. If not provided or None,
a freshly-allocated array is returned. A tuple (possible only as a
keyword argument) must have length equal to the number of outputs.
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
-------
out : ndarray or scalar
Output array of same shape as `x`.
This is a scalar if `x` is a scalar.

Examples
--------
>>> np.cosh(0)
1.0

The hyperbolic cosine describes the shape of a hanging cable:

>>> import matplotlib.pyplot as plt

>>> x = np.linspace(-4, 4, 1000)
>>> plt.plot(x, np.cosh(x))
>>> plt.show()

deg2rad = <ufunc 'deg2rad'>

deg2rad(x, /, out=None, *, where=True, casting='same_kind', order='K',
dtype=None, subok=True[, signature, extobj])

Convert angles from degrees to radians.

Parameters
----------
x : array_like
Angles in degrees.
out : ndarray, None, or tuple of ndarray and None, optional
A location into which the result is stored. If provided, it must have
a shape that the inputs broadcast to. If not provided or None,
a freshly-allocated array is returned. A tuple (possible only as a
keyword argument) must have length equal to the number of outputs.
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
-------
y : ndarray
The corresponding angle in radians.
This is a scalar if `x` is a scalar.
 See Also
--------
rad2deg : Convert angles from radians to degrees.
unwrap : Remove large jumps in angle by wrapping.

Notes
-----
.. versionadded:: 1.3.0

``deg2rad(x)`` is ``x * pi / 180``.

Examples
--------
>>> np.deg2rad(180)
3.1415926535897931

degrees = <ufunc 'degrees'>

degrees(x, /, out=None, *, where=True, casting='same_kind', order='K',
dtype=None, subok=True[, signature, extobj])

Convert angles from radians to degrees.

Parameters
----------
x : array_like
Input array in radians.
out : ndarray, None, or tuple of ndarray and None, optional
A location into which the result is stored. If provided, it must have
a shape that the inputs broadcast to. If not provided or None,
a freshly-allocated array is returned. A tuple (possible only as a
keyword argument) must have length equal to the number of outputs.
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
-------
y : ndarray of floats
The corresponding degree values; if `out` was supplied this is a
reference to it.
This is a scalar if `x` is a scalar.

See Also
--------
rad2deg : equivalent function

Examples
--------
Convert a radian array to degrees

>>> rad = np.arange(12.)*np.pi/6

>>> np.degrees(rad)
 array([ 0., 30., 60., 90., 120., 150., 180., 210., 240.,
270., 300., 330.])

>>> out = np.zeros((rad.shape))

>>> r = np.degrees(rad, out)
>>> np.all(r == out)
True

divide = <ufunc 'divide'>

divide(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K',
dtype=None, subok=True[, signature, extobj])

Divide arguments element-wise.

Parameters
----------
x1 : array_like
Dividend array.
x2 : array_like
Divisor array.
If ``x1.shape != x2.shape``, they must be broadcastable to a common
shape (which becomes the shape of the output).
out : ndarray, None, or tuple of ndarray and None, optional
A location into which the result is stored. If provided, it must have
a shape that the inputs broadcast to. If not provided or None,
a freshly-allocated array is returned. A tuple (possible only as a
keyword argument) must have length equal to the number of outputs.
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
-------
y : ndarray or scalar
The quotient ``x1/x2``, element-wise.
This is a scalar if both `x1` and `x2` are scalars.

See Also
--------
seterr : Set whether to raise or warn on overflow, underflow and
division by zero.

Notes
-----
Equivalent to ``x1`` / ``x2`` in terms of array-broadcasting.

The ``true_divide(x1, x2)`` function is an alias for

``divide(x1, x2)``.

Examples
--------
>>> np.divide(2.0, 4.0)
 0.5
>>> x1 = np.arange(9.0).reshape((3, 3))
>>> x2 = np.arange(3.0)
>>> np.divide(x1, x2)
array([[nan, 1. , 1. ],
[inf, 4. , 2.5],
[inf, 7. , 4. ]])

The ``/`` operator can be used as a shorthand for ``np.divide`` on

ndarrays.

>>> x1 = np.arange(9.0).reshape((3, 3))

>>> x2 = 2 * np.ones(3)
>>> x1 / x2
array([[0. , 0.5, 1. ],
[1.5, 2. , 2.5],
[3. , 3.5, 4. ]])

divmod = <ufunc 'divmod'>

divmod(x1, x2[, out1, out2], / [, out=(None, None)], *, where=True,
casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])

Return element-wise quotient and remainder simultaneously.

.. versionadded:: 1.13.0

``np.divmod(x, y)`` is equivalent to ``(x // y, x % y)``, but faster

because it avoids redundant work. It is used to implement the Python
built-in function ``divmod`` on NumPy arrays.

Parameters
----------
x1 : array_like
Dividend array.
x2 : array_like
Divisor array.
If ``x1.shape != x2.shape``, they must be broadcastable to a common
shape (which becomes the shape of the output).
out : ndarray, None, or tuple of ndarray and None, optional
A location into which the result is stored. If provided, it must have
a shape that the inputs broadcast to. If not provided or None,
a freshly-allocated array is returned. A tuple (possible only as a
keyword argument) must have length equal to the number of outputs.
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
-------
out1 : ndarray
Element-wise quotient resulting from floor division.
This is a scalar if both `x1` and `x2` are scalars.
 out2 : ndarray
Element-wise remainder from floor division.
This is a scalar if both `x1` and `x2` are scalars.

See Also
--------
floor_divide : Equivalent to Python's ``//`` operator.
remainder : Equivalent to Python's ``%`` operator.
modf : Equivalent to ``divmod(x, 1)`` for positive ``x`` with the return
values switched.

Examples
--------
>>> np.divmod(np.arange(5), 3)
(array([0, 0, 0, 1, 1]), array([0, 1, 2, 0, 1]))

The `divmod` function can be used as a shorthand for ``np.divmod`` on

ndarrays.

>>> x = np.arange(5)
>>> divmod(x, 3)
(array([0, 0, 0, 1, 1]), array([0, 1, 2, 0, 1]))

e = 2.718281828459045
equal = <ufunc 'equal'>
equal(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K',
dtype=None, subok=True[, signature, extobj])

Return (x1 == x2) element-wise.

Parameters
----------
x1, x2 : array_like
Input arrays.
If ``x1.shape != x2.shape``, they must be broadcastable to a common
shape (which becomes the shape of the output).
out : ndarray, None, or tuple of ndarray and None, optional
A location into which the result is stored. If provided, it must have
a shape that the inputs broadcast to. If not provided or None,
a freshly-allocated array is returned. A tuple (possible only as a
keyword argument) must have length equal to the number of outputs.
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
-------
out : ndarray or scalar
Output array, element-wise comparison of `x1` and `x2`.
Typically of type bool, unless ``dtype=object`` is passed.
This is a scalar if both `x1` and `x2` are scalars.
 See Also
--------
not_equal, greater_equal, less_equal, greater, less

Examples
--------
>>> np.equal([0, 1, 3], np.arange(3))
array([ True, True, False])

What is compared are values, not types. So an int (1) and an array of
length one can evaluate as True:

>>> np.equal(1, np.ones(1))

array([ True])

The ``==`` operator can be used as a shorthand for ``np.equal`` on

ndarrays.

>>> a = np.array([2, 4, 6])

>>> b = np.array([2, 4, 2])
>>> a == b
array([ True, True, False])

euler_gamma = 0.5772156649015329
exp = <ufunc 'exp'>
exp(x, /, out=None, *, where=True, casting='same_kind', order='K',
dtype=None, subok=True[, signature, extobj])

Calculate the exponential of all elements in the input array.

Parameters
----------
x : array_like
Input values.
out : ndarray, None, or tuple of ndarray and None, optional
A location into which the result is stored. If provided, it must have
a shape that the inputs broadcast to. If not provided or None,
a freshly-allocated array is returned. A tuple (possible only as a
keyword argument) must have length equal to the number of outputs.
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
-------
out : ndarray or scalar
Output array, element-wise exponential of `x`.
This is a scalar if `x` is a scalar.

See Also
--------
expm1 : Calculate ``exp(x) - 1`` for all elements in the array.
 exp2 : Calculate ``2**x`` for all elements in the array.

Notes
-----
The irrational number ``e`` is also known as Euler's number. It is
approximately 2.718281, and is the base of the natural logarithm,
``ln`` (this means that, if :math:`x = \ln y = \log_e y`,
then :math:`e^x = y`. For real input, ``exp(x)`` is always positive.

For complex arguments, ``x = a + ib``, we can write

:math:`e^x = e^a e^{ib}`. The first term, :math:`e^a`, is already
known (it is the real argument, described above). The second term,
:math:`e^{ib}`, is :math:`\cos b + i \sin b`, a function with
magnitude 1 and a periodic phase.

References
----------
.. [1] Wikipedia, "Exponential function",
https://en.wikipedia.org/wiki/Exponential_function
.. [2] M. Abramovitz and I. A. Stegun, "Handbook of Mathematical Functions
with Formulas, Graphs, and Mathematical Tables," Dover, 1964, p. 69,
https://personal.math.ubc.ca/~cbm/aands/page_69.htm

Examples
--------
Plot the magnitude and phase of ``exp(x)`` in the complex plane:

>>> import matplotlib.pyplot as plt

>>> x = np.linspace(-2*np.pi, 2*np.pi, 100)

>>> xx = x + 1j * x[:, np.newaxis] # a + ib over complex plane
>>> out = np.exp(xx)

>>> plt.subplot(121)
>>> plt.imshow(np.abs(out),
... extent=[-2*np.pi, 2*np.pi, -2*np.pi, 2*np.pi], cmap='gray')
>>> plt.title('Magnitude of exp(x)')

>>> plt.subplot(122)
>>> plt.imshow(np.angle(out),
... extent=[-2*np.pi, 2*np.pi, -2*np.pi, 2*np.pi], cmap='hsv')
>>> plt.title('Phase (angle) of exp(x)')
>>> plt.show()

exp2 = <ufunc 'exp2'>

exp2(x, /, out=None, *, where=True, casting='same_kind', order='K',
dtype=None, subok=True[, signature, extobj])

Calculate `2**p` for all `p` in the input array.

Parameters
----------
x : array_like
Input values.
out : ndarray, None, or tuple of ndarray and None, optional
A location into which the result is stored. If provided, it must have
a shape that the inputs broadcast to. If not provided or None,
a freshly-allocated array is returned. A tuple (possible only as a
keyword argument) must have length equal to the number of outputs.
 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
-------
out : ndarray or scalar
Element-wise 2 to the power `x`.
This is a scalar if `x` is a scalar.

See Also
--------
power

Notes
-----
.. versionadded:: 1.3.0

Examples
--------
>>> np.exp2([2, 3])
array([ 4., 8.])

expm1 = <ufunc 'expm1'>

expm1(x, /, out=None, *, where=True, casting='same_kind', order='K',
dtype=None, subok=True[, signature, extobj])

Calculate ``exp(x) - 1`` for all elements in the array.

Parameters
----------
x : array_like
Input values.
out : ndarray, None, or tuple of ndarray and None, optional
A location into which the result is stored. If provided, it must have
a shape that the inputs broadcast to. If not provided or None,
a freshly-allocated array is returned. A tuple (possible only as a
keyword argument) must have length equal to the number of outputs.
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
 -------
out : ndarray or scalar
Element-wise exponential minus one: ``out = exp(x) - 1``.
This is a scalar if `x` is a scalar.

See Also
--------
log1p : ``log(1 + x)``, the inverse of expm1.

Notes
-----
This function provides greater precision than ``exp(x) - 1``
for small values of ``x``.

Examples
--------
The true value of ``exp(1e-10) - 1`` is ``1.00000000005e-10`` to
about 32 significant digits. This example shows the superiority of
expm1 in this case.

>>> np.expm1(1e-10)
1.00000000005e-10
>>> np.exp(1e-10) - 1
1.000000082740371e-10

fabs = <ufunc 'fabs'>

fabs(x, /, out=None, *, where=True, casting='same_kind', order='K',
dtype=None, subok=True[, signature, extobj])

Compute the absolute values element-wise.

This function returns the absolute values (positive magnitude) of the

data in `x`. Complex values are not handled, use `absolute` to find the
absolute values of complex data.

Parameters
----------
x : array_like
The array of numbers for which the absolute values are required. If
`x` is a scalar, the result `y` will also be a scalar.
out : ndarray, None, or tuple of ndarray and None, optional
A location into which the result is stored. If provided, it must have
a shape that the inputs broadcast to. If not provided or None,
a freshly-allocated array is returned. A tuple (possible only as a
keyword argument) must have length equal to the number of outputs.
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
-------
 y : ndarray or scalar
The absolute values of `x`, the returned values are always floats.
This is a scalar if `x` is a scalar.

See Also
--------
absolute : Absolute values including `complex` types.

Examples
--------
>>> np.fabs(-1)
1.0
>>> np.fabs([-1.2, 1.2])
array([ 1.2, 1.2])

float_power = <ufunc 'float_power'>

float_power(x1, x2, /, out=None, *, where=True, casting='same_kind',
order='K', dtype=None, subok=True[, signature, extobj])

First array elements raised to powers from second array, element-wise.

Raise each base in `x1` to the positionally-corresponding power in `x2`.

`x1` and `x2` must be broadcastable to the same shape. This differs from
the power function in that integers, float16, and float32 are promoted to
floats with a minimum precision of float64 so that the result is always
inexact. The intent is that the function will return a usable result for
negative powers and seldom overflow for positive powers.

Negative values raised to a non-integral value will return ``nan``.

To get complex results, cast the input to complex, or specify the
``dtype`` to be ``complex`` (see the example below).

.. versionadded:: 1.12.0

Parameters
----------
x1 : array_like
The bases.
x2 : array_like
The exponents.
If ``x1.shape != x2.shape``, they must be broadcastable to a common
shape (which becomes the shape of the output).
out : ndarray, None, or tuple of ndarray and None, optional
A location into which the result is stored. If provided, it must have
a shape that the inputs broadcast to. If not provided or None,
a freshly-allocated array is returned. A tuple (possible only as a
keyword argument) must have length equal to the number of outputs.
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
 -------
y : ndarray
The bases in `x1` raised to the exponents in `x2`.
This is a scalar if both `x1` and `x2` are scalars.

See Also
--------
power : power function that preserves type

Examples
--------
Cube each element in a list.

>>> x1 = range(6)
>>> x1
[0, 1, 2, 3, 4, 5]
>>> np.float_power(x1, 3)
array([ 0., 1., 8., 27., 64., 125.])

Raise the bases to different exponents.

>>> x2 = [1.0, 2.0, 3.0, 3.0, 2.0, 1.0]

>>> np.float_power(x1, x2)
array([ 0., 1., 8., 27., 16., 5.])

The effect of broadcasting.

>>> x2 = np.array([[1, 2, 3, 3, 2, 1], [1, 2, 3, 3, 2, 1]])

>>> x2
array([[1, 2, 3, 3, 2, 1],
[1, 2, 3, 3, 2, 1]])
>>> np.float_power(x1, x2)
array([[ 0., 1., 8., 27., 16., 5.],
[ 0., 1., 8., 27., 16., 5.]])

Negative values raised to a non-integral value will result in ``nan``

(and a warning will be generated).

>>> x3 = np.array([-1, -4])

>>> with np.errstate(invalid='ignore'):
... p = np.float_power(x3, 1.5)
...
>>> p
array([nan, nan])

To get complex results, give the argument ``dtype=complex``.

>>> np.float_power(x3, 1.5, dtype=complex)

array([-1.83697020e-16-1.j, -1.46957616e-15-8.j])

floor = <ufunc 'floor'>

floor(x, /, out=None, *, where=True, casting='same_kind', order='K',
dtype=None, subok=True[, signature, extobj])

Return the floor of the input, element-wise.

The floor of the scalar `x` is the largest integer `i`, such that
`i <= x`. It is often denoted as :math:`\lfloor x \rfloor`.
 Parameters
----------
x : array_like
Input data.
out : ndarray, None, or tuple of ndarray and None, optional
A location into which the result is stored. If provided, it must have
a shape that the inputs broadcast to. If not provided or None,
a freshly-allocated array is returned. A tuple (possible only as a
keyword argument) must have length equal to the number of outputs.
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
-------
y : ndarray or scalar
The floor of each element in `x`.
This is a scalar if `x` is a scalar.

See Also
--------
ceil, trunc, rint, fix

Notes
-----
Some spreadsheet programs calculate the "floor-towards-zero", where
``floor(-2.5) == -2``. NumPy instead uses the definition of
`floor` where `floor(-2.5) == -3`. The "floor-towards-zero"
function is called ``fix`` in NumPy.

Examples
--------
>>> a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0])
>>> np.floor(a)
array([-2., -2., -1., 0., 1., 1., 2.])

floor_divide = <ufunc 'floor_divide'>

floor_divide(x1, x2, /, out=None, *, where=True, casting='same_kind',
order='K', dtype=None, subok=True[, signature, extobj])

Return the largest integer smaller or equal to the division of the inputs.
It is equivalent to the Python ``//`` operator and pairs with the
Python ``%`` (`remainder`), function so that ``a = a % b + b * (a // b)``
up to roundoff.

Parameters
----------
x1 : array_like
Numerator.
x2 : array_like
Denominator.
If ``x1.shape != x2.shape``, they must be broadcastable to a common
 shape (which becomes the shape of the output).
out : ndarray, None, or tuple of ndarray and None, optional
A location into which the result is stored. If provided, it must have
a shape that the inputs broadcast to. If not provided or None,
a freshly-allocated array is returned. A tuple (possible only as a
keyword argument) must have length equal to the number of outputs.
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
-------
y : ndarray
y = floor(`x1`/`x2`)
This is a scalar if both `x1` and `x2` are scalars.

See Also
--------
remainder : Remainder complementary to floor_divide.
divmod : Simultaneous floor division and remainder.
divide : Standard division.
floor : Round a number to the nearest integer toward minus infinity.
ceil : Round a number to the nearest integer toward infinity.

Examples
--------
>>> np.floor_divide(7,3)
2
>>> np.floor_divide([1., 2., 3., 4.], 2.5)
array([ 0., 0., 1., 1.])

The ``//`` operator can be used as a shorthand for ``np.floor_divide``

on ndarrays.

>>> x1 = np.array([1., 2., 3., 4.])

>>> x1 // 2.5
array([0., 0., 1., 1.])

fmax = <ufunc 'fmax'>

fmax(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K',
dtype=None, subok=True[, signature, extobj])

Element-wise maximum of array elements.

Compare two arrays and return a new array containing the element-wise
maxima. If one of the elements being compared is a NaN, then the
non-nan element is returned. If both elements are NaNs then the first
is returned. The latter distinction is important for complex NaNs,
which are defined as at least one of the real or imaginary parts being
a NaN. The net effect is that NaNs are ignored when possible.

Parameters
----------
x1, x2 : array_like
The arrays holding the elements to be compared.
If ``x1.shape != x2.shape``, they must be broadcastable to a common
shape (which becomes the shape of the output).
out : ndarray, None, or tuple of ndarray and None, optional
A location into which the result is stored. If provided, it must have
a shape that the inputs broadcast to. If not provided or None,
a freshly-allocated array is returned. A tuple (possible only as a
keyword argument) must have length equal to the number of outputs.
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
-------
y : ndarray or scalar
The maximum of `x1` and `x2`, element-wise.
This is a scalar if both `x1` and `x2` are scalars.

See Also
--------
fmin :
Element-wise minimum of two arrays, ignores NaNs.
maximum :
Element-wise maximum of two arrays, propagates NaNs.
amax :
The maximum value of an array along a given axis, propagates NaNs.
nanmax :
The maximum value of an array along a given axis, ignores NaNs.

minimum, amin, nanmin

Notes
-----
.. versionadded:: 1.3.0

The fmax is equivalent to ``np.where(x1 >= x2, x1, x2)`` when neither
x1 nor x2 are NaNs, but it is faster and does proper broadcasting.

Examples
--------
>>> np.fmax([2, 3, 4], [1, 5, 2])
array([ 2., 5., 4.])

>>> np.fmax(np.eye(2), [0.5, 2])

array([[ 1. , 2. ],
[ 0.5, 2. ]])

>>> np.fmax([np.nan, 0, np.nan],[0, np.nan, np.nan])

array([ 0., 0., nan])
 fmin = <ufunc 'fmin'>
fmin(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K',
dtype=None, subok=True[, signature, extobj])

Element-wise minimum of array elements.

Compare two arrays and return a new array containing the element-wise
minima. If one of the elements being compared is a NaN, then the
non-nan element is returned. If both elements are NaNs then the first
is returned. The latter distinction is important for complex NaNs,
which are defined as at least one of the real or imaginary parts being
a NaN. The net effect is that NaNs are ignored when possible.

Parameters
----------
x1, x2 : array_like
The arrays holding the elements to be compared.
If ``x1.shape != x2.shape``, they must be broadcastable to a common
shape (which becomes the shape of the output).
out : ndarray, None, or tuple of ndarray and None, optional
A location into which the result is stored. If provided, it must have
a shape that the inputs broadcast to. If not provided or None,
a freshly-allocated array is returned. A tuple (possible only as a
keyword argument) must have length equal to the number of outputs.
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
-------
y : ndarray or scalar
The minimum of `x1` and `x2`, element-wise.
This is a scalar if both `x1` and `x2` are scalars.

See Also
--------
fmax :
Element-wise maximum of two arrays, ignores NaNs.
minimum :
Element-wise minimum of two arrays, propagates NaNs.
amin :
The minimum value of an array along a given axis, propagates NaNs.
nanmin :
The minimum value of an array along a given axis, ignores NaNs.

maximum, amax, nanmax

Notes
-----
.. versionadded:: 1.3.0

The fmin is equivalent to ``np.where(x1 <= x2, x1, x2)`` when neither
 x1 nor x2 are NaNs, but it is faster and does proper broadcasting.

Examples
--------
>>> np.fmin([2, 3, 4], [1, 5, 2])
array([1, 3, 2])

>>> np.fmin(np.eye(2), [0.5, 2])

array([[ 0.5, 0. ],
[ 0. , 1. ]])

>>> np.fmin([np.nan, 0, np.nan],[0, np.nan, np.nan])

array([ 0., 0., nan])

fmod = <ufunc 'fmod'>

fmod(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K',
dtype=None, subok=True[, signature, extobj])

Returns the element-wise remainder of division.

This is the NumPy implementation of the C library function fmod, the

remainder has the same sign as the dividend `x1`. It is equivalent to
the Matlab(TM) ``rem`` function and should not be confused with the
Python modulus operator ``x1 % x2``.

Parameters
----------
x1 : array_like
Dividend.
x2 : array_like
Divisor.
If ``x1.shape != x2.shape``, they must be broadcastable to a common
shape (which becomes the shape of the output).
out : ndarray, None, or tuple of ndarray and None, optional
A location into which the result is stored. If provided, it must have
a shape that the inputs broadcast to. If not provided or None,
a freshly-allocated array is returned. A tuple (possible only as a
keyword argument) must have length equal to the number of outputs.
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
-------
y : array_like
The remainder of the division of `x1` by `x2`.
This is a scalar if both `x1` and `x2` are scalars.

See Also
--------
remainder : Equivalent to the Python ``%`` operator.
divide
 Notes
-----
The result of the modulo operation for negative dividend and divisors
is bound by conventions. For `fmod`, the sign of result is the sign of
the dividend, while for `remainder` the sign of the result is the sign
of the divisor. The `fmod` function is equivalent to the Matlab(TM)
``rem`` function.

Examples
--------
>>> np.fmod([-3, -2, -1, 1, 2, 3], 2)
array([-1, 0, -1, 1, 0, 1])
>>> np.remainder([-3, -2, -1, 1, 2, 3], 2)
array([1, 0, 1, 1, 0, 1])

>>> np.fmod([5, 3], [2, 2.])

array([ 1., 1.])
>>> a = np.arange(-3, 3).reshape(3, 2)
>>> a
array([[-3, -2],
[-1, 0],
[ 1, 2]])
>>> np.fmod(a, [2,2])
array([[-1, 0],
[-1, 0],
[ 1, 0]])

frexp = <ufunc 'frexp'>

frexp(x[, out1, out2], / [, out=(None, None)], *, where=True,
casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])

Decompose the elements of x into mantissa and twos exponent.

Returns (`mantissa`, `exponent`), where ``x = mantissa * 2**exponent``.

The mantissa lies in the open interval(-1, 1), while the twos
exponent is a signed integer.

Parameters
----------
x : array_like
Array of numbers to be decomposed.
out1 : ndarray, optional
Output array for the mantissa. Must have the same shape as `x`.
out2 : ndarray, optional
Output array for the exponent. Must have the same shape as `x`.
out : ndarray, None, or tuple of ndarray and None, optional
A location into which the result is stored. If provided, it must have
a shape that the inputs broadcast to. If not provided or None,
a freshly-allocated array is returned. A tuple (possible only as a
keyword argument) must have length equal to the number of outputs.
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
-------
mantissa : ndarray
Floating values between -1 and 1.
This is a scalar if `x` is a scalar.
exponent : ndarray
Integer exponents of 2.
This is a scalar if `x` is a scalar.

See Also
--------
ldexp : Compute ``y = x1 * 2**x2``, the inverse of `frexp`.

Notes
-----
Complex dtypes are not supported, they will raise a TypeError.

Examples
--------
>>> x = np.arange(9)
>>> y1, y2 = np.frexp(x)
>>> y1
array([ 0. , 0.5 , 0.5 , 0.75 , 0.5 , 0.625, 0.75 , 0.875,
0.5 ])
>>> y2
array([0, 1, 2, 2, 3, 3, 3, 3, 4])
>>> y1 * 2**y2
array([ 0., 1., 2., 3., 4., 5., 6., 7., 8.])

gcd = <ufunc 'gcd'>

gcd(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K',
dtype=None, subok=True[, signature, extobj])

Returns the greatest common divisor of ``|x1|`` and ``|x2|``

Parameters
----------
x1, x2 : array_like, int
Arrays of values.
If ``x1.shape != x2.shape``, they must be broadcastable to a common
shape (which becomes the shape of the output).

Returns
-------
y : ndarray or scalar
The greatest common divisor of the absolute value of the inputs
This is a scalar if both `x1` and `x2` are scalars.

See Also
--------
lcm : The lowest common multiple

Examples
--------
>>> np.gcd(12, 20)
4
 >>> np.gcd.reduce([15, 25, 35])
5
>>> np.gcd(np.arange(6), 20)
array([20, 1, 2, 1, 4, 5])

greater = <ufunc 'greater'>

greater(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K',
dtype=None, subok=True[, signature, extobj])

Return the truth value of (x1 > x2) element-wise.

Parameters
----------
x1, x2 : array_like
Input arrays.
If ``x1.shape != x2.shape``, they must be broadcastable to a common
shape (which becomes the shape of the output).
out : ndarray, None, or tuple of ndarray and None, optional
A location into which the result is stored. If provided, it must have
a shape that the inputs broadcast to. If not provided or None,
a freshly-allocated array is returned. A tuple (possible only as a
keyword argument) must have length equal to the number of outputs.
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
-------
out : ndarray or scalar
Output array, element-wise comparison of `x1` and `x2`.
Typically of type bool, unless ``dtype=object`` is passed.
This is a scalar if both `x1` and `x2` are scalars.

See Also
--------
greater_equal, less, less_equal, equal, not_equal

Examples
--------
>>> np.greater([4,2],[2,2])
array([ True, False])

The ``>`` operator can be used as a shorthand for ``np.greater`` on

ndarrays.

>>> a = np.array([4, 2])

>>> b = np.array([2, 2])
>>> a > b
array([ True, False])

greater_equal = <ufunc 'greater_equal'>

 greater_equal(x1, x2, /, out=None, *, where=True, casting='same_kind',
order='K', dtype=None, subok=True[, signature, extobj])

Return the truth value of (x1 >= x2) element-wise.

Parameters
----------
x1, x2 : array_like
Input arrays.
If ``x1.shape != x2.shape``, they must be broadcastable to a common
shape (which becomes the shape of the output).
out : ndarray, None, or tuple of ndarray and None, optional
A location into which the result is stored. If provided, it must have
a shape that the inputs broadcast to. If not provided or None,
a freshly-allocated array is returned. A tuple (possible only as a
keyword argument) must have length equal to the number of outputs.
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
-------
out : bool or ndarray of bool
Output array, element-wise comparison of `x1` and `x2`.
Typically of type bool, unless ``dtype=object`` is passed.
This is a scalar if both `x1` and `x2` are scalars.

See Also
--------
greater, less, less_equal, equal, not_equal

Examples
--------
>>> np.greater_equal([4, 2, 1], [2, 2, 2])
array([ True, True, False])

The ``>=`` operator can be used as a shorthand for ``np.greater_equal``

on ndarrays.

>>> a = np.array([4, 2, 1])

>>> b = np.array([2, 2, 2])
>>> a >= b
array([ True, True, False])

heaviside = <ufunc 'heaviside'>

heaviside(x1, x2, /, out=None, *, where=True, casting='same_kind',
order='K', dtype=None, subok=True[, signature, extobj])

Compute the Heaviside step function.

The Heaviside step function is defined as::

 0 if x1 < 0
heaviside(x1, x2) = x2 if x1 == 0
1 if x1 > 0

where `x2` is often taken to be 0.5, but 0 and 1 are also sometimes used.

Parameters
----------
x1 : array_like
Input values.
x2 : array_like
The value of the function when x1 is 0.
If ``x1.shape != x2.shape``, they must be broadcastable to a common
shape (which becomes the shape of the output).
out : ndarray, None, or tuple of ndarray and None, optional
A location into which the result is stored. If provided, it must have
a shape that the inputs broadcast to. If not provided or None,
a freshly-allocated array is returned. A tuple (possible only as a
keyword argument) must have length equal to the number of outputs.
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
-------
out : ndarray or scalar
The output array, element-wise Heaviside step function of `x1`.
This is a scalar if both `x1` and `x2` are scalars.

Notes
-----
.. versionadded:: 1.13.0

References
----------
.. Wikipedia, "Heaviside step function",
https://en.wikipedia.org/wiki/Heaviside_step_function

Examples
--------
>>> np.heaviside([-1.5, 0, 2.0], 0.5)
array([ 0. , 0.5, 1. ])
>>> np.heaviside([-1.5, 0, 2.0], 1)
array([ 0., 1., 1.])

hypot = <ufunc 'hypot'>

hypot(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K',
dtype=None, subok=True[, signature, extobj])

Given the "legs" of a right triangle, return its hypotenuse.

Equivalent to ``sqrt(x1**2 + x2**2)``, element-wise. If `x1` or

 `x2` is scalar_like (i.e., unambiguously cast-able to a scalar type),
it is broadcast for use with each element of the other argument.
(See Examples)

Parameters
----------
x1, x2 : array_like
Leg of the triangle(s).
If ``x1.shape != x2.shape``, they must be broadcastable to a common
shape (which becomes the shape of the output).
out : ndarray, None, or tuple of ndarray and None, optional
A location into which the result is stored. If provided, it must have
a shape that the inputs broadcast to. If not provided or None,
a freshly-allocated array is returned. A tuple (possible only as a
keyword argument) must have length equal to the number of outputs.
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
-------
z : ndarray
The hypotenuse of the triangle(s).
This is a scalar if both `x1` and `x2` are scalars.

Examples
--------
>>> np.hypot(3*np.ones((3, 3)), 4*np.ones((3, 3)))
array([[ 5., 5., 5.],
[ 5., 5., 5.],
[ 5., 5., 5.]])

Example showing broadcast of scalar_like argument:

>>> np.hypot(3*np.ones((3, 3)), [4])

array([[ 5., 5., 5.],
[ 5., 5., 5.],
[ 5., 5., 5.]])

index_exp = <numpy.lib.index_tricks.IndexExpression object>

inf = inf
infty = inf
invert = <ufunc 'invert'>
invert(x, /, out=None, *, where=True, casting='same_kind', order='K',
dtype=None, subok=True[, signature, extobj])

Compute bit-wise inversion, or bit-wise NOT, element-wise.

Computes the bit-wise NOT of the underlying binary representation of

the integers in the input arrays. This ufunc implements the C/Python
operator ``~``.
For signed integer inputs, the two's complement is returned. In a
two's-complement system negative numbers are represented by the two's
complement of the absolute value. This is the most common method of
representing signed integers on computers [1]_. A N-bit
two's-complement system can represent every integer in the range
:math:`-2^{N-1}` to :math:`+2^{N-1}-1`.

Parameters
----------
x : array_like
Only integer and boolean types are handled.
out : ndarray, None, or tuple of ndarray and None, optional
A location into which the result is stored. If provided, it must have
a shape that the inputs broadcast to. If not provided or None,
a freshly-allocated array is returned. A tuple (possible only as a
keyword argument) must have length equal to the number of outputs.
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
-------
out : ndarray or scalar
Result.
This is a scalar if `x` is a scalar.

See Also
--------
bitwise_and, bitwise_or, bitwise_xor
logical_not
binary_repr :
Return the binary representation of the input number as a string.

Notes
-----
`bitwise_not` is an alias for `invert`:

>>> np.bitwise_not is np.invert

True

References
----------
.. [1] Wikipedia, "Two's complement",
https://en.wikipedia.org/wiki/Two's_complement

Examples
--------
We've seen that 13 is represented by ``00001101``.
The invert or bit-wise NOT of 13 is then:

>>> x = np.invert(np.array(13, dtype=np.uint8))

>>> x
 242
>>> np.binary_repr(x, width=8)
'11110010'

The result depends on the bit-width:

>>> x = np.invert(np.array(13, dtype=np.uint16))

>>> x
65522
>>> np.binary_repr(x, width=16)
'1111111111110010'

When using signed integer types the result is the two's complement of
the result for the unsigned type:

>>> np.invert(np.array([13], dtype=np.int8))

array([-14], dtype=int8)
>>> np.binary_repr(-14, width=8)
'11110010'

Booleans are accepted as well:

>>> np.invert(np.array([True, False]))

array([False, True])

The ``~`` operator can be used as a shorthand for ``np.invert`` on

ndarrays.

>>> x1 = np.array([True, False])

>>> ~x1
array([False, True])

isfinite = <ufunc 'isfinite'>

isfinite(x, /, out=None, *, where=True, casting='same_kind', order='K',
dtype=None, subok=True[, signature, extobj])

Test element-wise for finiteness (not infinity and not Not a Number).

The result is returned as a boolean array.

Parameters
----------
x : array_like
Input values.
out : ndarray, None, or tuple of ndarray and None, optional
A location into which the result is stored. If provided, it must have
a shape that the inputs broadcast to. If not provided or None,
a freshly-allocated array is returned. A tuple (possible only as a
keyword argument) must have length equal to the number of outputs.
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
-------
y : ndarray, bool
True where ``x`` is not positive infinity, negative infinity,
or NaN; false otherwise.
This is a scalar if `x` is a scalar.

See Also
--------
isinf, isneginf, isposinf, isnan

Notes
-----
Not a Number, positive infinity and negative infinity are considered
to be non-finite.

NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic
(IEEE 754). This means that Not a Number is not equivalent to infinity.
Also that positive infinity is not equivalent to negative infinity. But
infinity is equivalent to positive infinity. Errors result if the
second argument is also supplied when `x` is a scalar input, or if
first and second arguments have different shapes.

Examples
--------
>>> np.isfinite(1)
True
>>> np.isfinite(0)
True
>>> np.isfinite(np.nan)
False
>>> np.isfinite(np.inf)
False
>>> np.isfinite(np.NINF)
False
>>> np.isfinite([np.log(-1.),1.,np.log(0)])
array([False, True, False])

>>> x = np.array([-np.inf, 0., np.inf])

>>> y = np.array([2, 2, 2])
>>> np.isfinite(x, y)
array([0, 1, 0])
>>> y
array([0, 1, 0])

isinf = <ufunc 'isinf'>

isinf(x, /, out=None, *, where=True, casting='same_kind', order='K',
dtype=None, subok=True[, signature, extobj])

Test element-wise for positive or negative infinity.

Returns a boolean array of the same shape as `x`, True where ``x ==
+/-inf``, otherwise False.

Parameters
----------
x : array_like
Input values
 out : ndarray, None, or tuple of ndarray and None, optional
A location into which the result is stored. If provided, it must have
a shape that the inputs broadcast to. If not provided or None,
a freshly-allocated array is returned. A tuple (possible only as a
keyword argument) must have length equal to the number of outputs.
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
-------
y : bool (scalar) or boolean ndarray
True where ``x`` is positive or negative infinity, false otherwise.
This is a scalar if `x` is a scalar.

See Also
--------
isneginf, isposinf, isnan, isfinite

Notes
-----
NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic
(IEEE 754).

Errors result if the second argument is supplied when the first

argument is a scalar, or if the first and second arguments have
different shapes.

Examples
--------
>>> np.isinf(np.inf)
True
>>> np.isinf(np.nan)
False
>>> np.isinf(np.NINF)
True
>>> np.isinf([np.inf, -np.inf, 1.0, np.nan])
array([ True, True, False, False])

>>> x = np.array([-np.inf, 0., np.inf])

>>> y = np.array([2, 2, 2])
>>> np.isinf(x, y)
array([1, 0, 1])
>>> y
array([1, 0, 1])

isnan = <ufunc 'isnan'>

isnan(x, /, out=None, *, where=True, casting='same_kind', order='K',
dtype=None, subok=True[, signature, extobj])

Test element-wise for NaN and return result as a boolean array.

 Parameters
----------
x : array_like
Input array.
out : ndarray, None, or tuple of ndarray and None, optional
A location into which the result is stored. If provided, it must have
a shape that the inputs broadcast to. If not provided or None,
a freshly-allocated array is returned. A tuple (possible only as a
keyword argument) must have length equal to the number of outputs.
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
-------
y : ndarray or bool
True where ``x`` is NaN, false otherwise.
This is a scalar if `x` is a scalar.

See Also
--------
isinf, isneginf, isposinf, isfinite, isnat

Notes
-----
NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic
(IEEE 754). This means that Not a Number is not equivalent to infinity.

Examples
--------
>>> np.isnan(np.nan)
True
>>> np.isnan(np.inf)
False
>>> np.isnan([np.log(-1.),1.,np.log(0)])
array([ True, False, False])

isnat = <ufunc 'isnat'>

isnat(x, /, out=None, *, where=True, casting='same_kind', order='K',
dtype=None, subok=True[, signature, extobj])

Test element-wise for NaT (not a time) and return result as a boolean
array.

.. versionadded:: 1.13.0

Parameters
----------
x : array_like
Input array with datetime or timedelta data type.
out : ndarray, None, or tuple of ndarray and None, optional
A location into which the result is stored. If provided, it must have
 a shape that the inputs broadcast to. If not provided or None,
a freshly-allocated array is returned. A tuple (possible only as a
keyword argument) must have length equal to the number of outputs.
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
-------
y : ndarray or bool
True where ``x`` is NaT, false otherwise.
This is a scalar if `x` is a scalar.

See Also
--------
isnan, isinf, isneginf, isposinf, isfinite

Examples
--------
>>> np.isnat(np.datetime64("NaT"))
True
>>> np.isnat(np.datetime64("2016-01-01"))
False
>>> np.isnat(np.array(["NaT", "2016-01-01"], dtype="datetime64[ns]"))
array([ True, False])

lcm = <ufunc 'lcm'>

lcm(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K',
dtype=None, subok=True[, signature, extobj])

Returns the lowest common multiple of ``|x1|`` and ``|x2|``

Parameters
----------
x1, x2 : array_like, int
Arrays of values.
If ``x1.shape != x2.shape``, they must be broadcastable to a common
shape (which becomes the shape of the output).

Returns
-------
y : ndarray or scalar
The lowest common multiple of the absolute value of the inputs
This is a scalar if both `x1` and `x2` are scalars.

See Also
--------
gcd : The greatest common divisor

Examples
--------
>>> np.lcm(12, 20)
 60
>>> np.lcm.reduce([3, 12, 20])
60
>>> np.lcm.reduce([40, 12, 20])
120
>>> np.lcm(np.arange(6), 20)
array([ 0, 20, 20, 60, 20, 20])

ldexp = <ufunc 'ldexp'>

ldexp(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K',
dtype=None, subok=True[, signature, extobj])

Returns x1 * 2**x2, element-wise.

The mantissas `x1` and twos exponents `x2` are used to construct
floating point numbers ``x1 * 2**x2``.

Parameters
----------
x1 : array_like
Array of multipliers.
x2 : array_like, int
Array of twos exponents.
If ``x1.shape != x2.shape``, they must be broadcastable to a common
shape (which becomes the shape of the output).
out : ndarray, None, or tuple of ndarray and None, optional
A location into which the result is stored. If provided, it must have
a shape that the inputs broadcast to. If not provided or None,
a freshly-allocated array is returned. A tuple (possible only as a
keyword argument) must have length equal to the number of outputs.
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
-------
y : ndarray or scalar
The result of ``x1 * 2**x2``.
This is a scalar if both `x1` and `x2` are scalars.

See Also
--------
frexp : Return (y1, y2) from ``x = y1 * 2**y2``, inverse to `ldexp`.

Notes
-----
Complex dtypes are not supported, they will raise a TypeError.

`ldexp` is useful as the inverse of `frexp`, if used by itself it is

more clear to simply use the expression ``x1 * 2**x2``.

Examples
 --------
>>> np.ldexp(5, np.arange(4))
array([ 5., 10., 20., 40.], dtype=float16)

>>> x = np.arange(6)
>>> np.ldexp(*np.frexp(x))
array([ 0., 1., 2., 3., 4., 5.])

left_shift = <ufunc 'left_shift'>

left_shift(x1, x2, /, out=None, *, where=True, casting='same_kind',
order='K', dtype=None, subok=True[, signature, extobj])

Shift the bits of an integer to the left.

Bits are shifted to the left by appending `x2` 0s at the right of `x1`.
Since the internal representation of numbers is in binary format, this
operation is equivalent to multiplying `x1` by ``2**x2``.

Parameters
----------
x1 : array_like of integer type
Input values.
x2 : array_like of integer type
Number of zeros to append to `x1`. Has to be non-negative.
If ``x1.shape != x2.shape``, they must be broadcastable to a common
shape (which becomes the shape of the output).
out : ndarray, None, or tuple of ndarray and None, optional
A location into which the result is stored. If provided, it must have
a shape that the inputs broadcast to. If not provided or None,
a freshly-allocated array is returned. A tuple (possible only as a
keyword argument) must have length equal to the number of outputs.
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
-------
out : array of integer type
Return `x1` with bits shifted `x2` times to the left.
This is a scalar if both `x1` and `x2` are scalars.

See Also
--------
right_shift : Shift the bits of an integer to the right.
binary_repr : Return the binary representation of the input number
as a string.

Examples
--------
>>> np.binary_repr(5)
'101'
>>> np.left_shift(5, 2)
 20
>>> np.binary_repr(20)
'10100'

>>> np.left_shift(5, [1,2,3])

array([10, 20, 40])

Note that the dtype of the second argument may change the dtype of the
result and can lead to unexpected results in some cases (see
:ref:`Casting Rules <ufuncs.casting>`):

>>> a = np.left_shift(np.uint8(255), 1) # Expect 254

>>> print(a, type(a)) # Unexpected result due to upcasting
510 <class 'numpy.int64'>
>>> b = np.left_shift(np.uint8(255), np.uint8(1))
>>> print(b, type(b))
254 <class 'numpy.uint8'>

The ``<<`` operator can be used as a shorthand for ``np.left_shift`` on

ndarrays.

>>> x1 = 5
>>> x2 = np.array([1, 2, 3])
>>> x1 << x2
array([10, 20, 40])

less = <ufunc 'less'>

less(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K',
dtype=None, subok=True[, signature, extobj])

Return the truth value of (x1 < x2) element-wise.

Parameters
----------
x1, x2 : array_like
Input arrays.
If ``x1.shape != x2.shape``, they must be broadcastable to a common
shape (which becomes the shape of the output).
out : ndarray, None, or tuple of ndarray and None, optional
A location into which the result is stored. If provided, it must have
a shape that the inputs broadcast to. If not provided or None,
a freshly-allocated array is returned. A tuple (possible only as a
keyword argument) must have length equal to the number of outputs.
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
-------
out : ndarray or scalar
Output array, element-wise comparison of `x1` and `x2`.
Typically of type bool, unless ``dtype=object`` is passed.
 This is a scalar if both `x1` and `x2` are scalars.

See Also
--------
greater, less_equal, greater_equal, equal, not_equal

Examples
--------
>>> np.less([1, 2], [2, 2])
array([ True, False])

The ``<`` operator can be used as a shorthand for ``np.less`` on ndarrays.

>>> a = np.array([1, 2])

>>> b = np.array([2, 2])
>>> a < b
array([ True, False])

less_equal = <ufunc 'less_equal'>

less_equal(x1, x2, /, out=None, *, where=True, casting='same_kind',
order='K', dtype=None, subok=True[, signature, extobj])

Return the truth value of (x1 <= x2) element-wise.

Parameters
----------
x1, x2 : array_like
Input arrays.
If ``x1.shape != x2.shape``, they must be broadcastable to a common
shape (which becomes the shape of the output).
out : ndarray, None, or tuple of ndarray and None, optional
A location into which the result is stored. If provided, it must have
a shape that the inputs broadcast to. If not provided or None,
a freshly-allocated array is returned. A tuple (possible only as a
keyword argument) must have length equal to the number of outputs.
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
-------
out : ndarray or scalar
Output array, element-wise comparison of `x1` and `x2`.
Typically of type bool, unless ``dtype=object`` is passed.
This is a scalar if both `x1` and `x2` are scalars.

See Also
--------
greater, less, greater_equal, equal, not_equal

Examples
--------
 >>> np.less_equal([4, 2, 1], [2, 2, 2])
array([False, True, True])

The ``<=`` operator can be used as a shorthand for ``np.less_equal`` on

ndarrays.

>>> a = np.array([4, 2, 1])

>>> b = np.array([2, 2, 2])
>>> a <= b
array([False, True, True])

little_endian = True
log = <ufunc 'log'>
log(x, /, out=None, *, where=True, casting='same_kind', order='K',
dtype=None, subok=True[, signature, extobj])

Natural logarithm, element-wise.

The natural logarithm `log` is the inverse of the exponential function,

so that `log(exp(x)) = x`. The natural logarithm is logarithm in base
`e`.

Parameters
----------
x : array_like
Input value.
out : ndarray, None, or tuple of ndarray and None, optional
A location into which the result is stored. If provided, it must have
a shape that the inputs broadcast to. If not provided or None,
a freshly-allocated array is returned. A tuple (possible only as a
keyword argument) must have length equal to the number of outputs.
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
-------
y : ndarray
The natural logarithm of `x`, element-wise.
This is a scalar if `x` is a scalar.

See Also
--------
log10, log2, log1p, emath.log

Notes
-----
Logarithm is a multivalued function: for each `x` there is an infinite
number of `z` such that `exp(z) = x`. The convention is to return the
`z` whose imaginary part lies in `(-pi, pi]`.

For real-valued input data types, `log` always returns real output. For
 each value that cannot be expressed as a real number or infinity, it
yields ``nan`` and sets the `invalid` floating point error flag.

For complex-valued input, `log` is a complex analytical function that

has a branch cut `[-inf, 0]` and is continuous from above on it. `log`
handles the floating-point negative zero as an infinitesimal negative
number, conforming to the C99 standard.

In the cases where the input has a negative real part and a very small
negative complex part (approaching 0), the result is so close to `-pi`
that it evaluates to exactly `-pi`.

References
----------
.. [1] M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions",
10th printing, 1964, pp. 67.
https://personal.math.ubc.ca/~cbm/aands/page_67.htm
.. [2] Wikipedia, "Logarithm". https://en.wikipedia.org/wiki/Logarithm

Examples
--------
>>> np.log([1, np.e, np.e**2, 0])
array([ 0., 1., 2., -Inf])

log10 = <ufunc 'log10'>

log10(x, /, out=None, *, where=True, casting='same_kind', order='K',
dtype=None, subok=True[, signature, extobj])

Return the base 10 logarithm of the input array, element-wise.

Parameters
----------
x : array_like
Input values.
out : ndarray, None, or tuple of ndarray and None, optional
A location into which the result is stored. If provided, it must have
a shape that the inputs broadcast to. If not provided or None,
a freshly-allocated array is returned. A tuple (possible only as a
keyword argument) must have length equal to the number of outputs.
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
-------
y : ndarray
The logarithm to the base 10 of `x`, element-wise. NaNs are
returned where x is negative.
This is a scalar if `x` is a scalar.

See Also
--------
 emath.log10

Notes
-----
Logarithm is a multivalued function: for each `x` there is an infinite
number of `z` such that `10**z = x`. The convention is to return the
`z` whose imaginary part lies in `(-pi, pi]`.

For real-valued input data types, `log10` always returns real output.
For each value that cannot be expressed as a real number or infinity,
it yields ``nan`` and sets the `invalid` floating point error flag.

For complex-valued input, `log10` is a complex analytical function that

has a branch cut `[-inf, 0]` and is continuous from above on it.
`log10` handles the floating-point negative zero as an infinitesimal
negative number, conforming to the C99 standard.

In the cases where the input has a negative real part and a very small
negative complex part (approaching 0), the result is so close to `-pi`
that it evaluates to exactly `-pi`.

References
----------
.. [1] M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions",
10th printing, 1964, pp. 67.
https://personal.math.ubc.ca/~cbm/aands/page_67.htm
.. [2] Wikipedia, "Logarithm". https://en.wikipedia.org/wiki/Logarithm

Examples
--------
>>> np.log10([1e-15, -3.])
array([-15., nan])

log1p = <ufunc 'log1p'>

log1p(x, /, out=None, *, where=True, casting='same_kind', order='K',
dtype=None, subok=True[, signature, extobj])

Return the natural logarithm of one plus the input array, element-wise.

Calculates ``log(1 + x)``.

Parameters
----------
x : array_like
Input values.
out : ndarray, None, or tuple of ndarray and None, optional
A location into which the result is stored. If provided, it must have
a shape that the inputs broadcast to. If not provided or None,
a freshly-allocated array is returned. A tuple (possible only as a
keyword argument) must have length equal to the number of outputs.
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
-------
y : ndarray
Natural logarithm of `1 + x`, element-wise.
This is a scalar if `x` is a scalar.

See Also
--------
expm1 : ``exp(x) - 1``, the inverse of `log1p`.

Notes
-----
For real-valued input, `log1p` is accurate also for `x` so small
that `1 + x == 1` in floating-point accuracy.

Logarithm is a multivalued function: for each `x` there is an infinite

number of `z` such that `exp(z) = 1 + x`. The convention is to return
the `z` whose imaginary part lies in `[-pi, pi]`.

For real-valued input data types, `log1p` always returns real output.
For each value that cannot be expressed as a real number or infinity,
it yields ``nan`` and sets the `invalid` floating point error flag.

For complex-valued input, `log1p` is a complex analytical function that

has a branch cut `[-inf, -1]` and is continuous from above on it.
`log1p` handles the floating-point negative zero as an infinitesimal
negative number, conforming to the C99 standard.

References
----------
.. [1] M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions",
10th printing, 1964, pp. 67.
https://personal.math.ubc.ca/~cbm/aands/page_67.htm
.. [2] Wikipedia, "Logarithm". https://en.wikipedia.org/wiki/Logarithm

Examples
--------
>>> np.log1p(1e-99)
1e-99
>>> np.log(1 + 1e-99)
0.0

log2 = <ufunc 'log2'>

log2(x, /, out=None, *, where=True, casting='same_kind', order='K',
dtype=None, subok=True[, signature, extobj])

Base-2 logarithm of `x`.

Parameters
----------
x : array_like
Input values.
out : ndarray, None, or tuple of ndarray and None, optional
A location into which the result is stored. If provided, it must have
a shape that the inputs broadcast to. If not provided or None,
a freshly-allocated array is returned. A tuple (possible only as a
keyword argument) must have length equal to the number of outputs.
 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
-------
y : ndarray
Base-2 logarithm of `x`.
This is a scalar if `x` is a scalar.

See Also
--------
log, log10, log1p, emath.log2

Notes
-----
.. versionadded:: 1.3.0

Logarithm is a multivalued function: for each `x` there is an infinite

number of `z` such that `2**z = x`. The convention is to return the `z`
whose imaginary part lies in `(-pi, pi]`.

For real-valued input data types, `log2` always returns real output.
For each value that cannot be expressed as a real number or infinity,
it yields ``nan`` and sets the `invalid` floating point error flag.

For complex-valued input, `log2` is a complex analytical function that

has a branch cut `[-inf, 0]` and is continuous from above on it. `log2`
handles the floating-point negative zero as an infinitesimal negative
number, conforming to the C99 standard.

In the cases where the input has a negative real part and a very small
negative complex part (approaching 0), the result is so close to `-pi`
that it evaluates to exactly `-pi`.

Examples
--------
>>> x = np.array([0, 1, 2, 2**4])
>>> np.log2(x)
array([-Inf, 0., 1., 4.])

>>> xi = np.array([0+1.j, 1, 2+0.j, 4.j])

>>> np.log2(xi)
array([ 0.+2.26618007j, 0.+0.j , 1.+0.j , 2.+2.26618007j])

logaddexp = <ufunc 'logaddexp'>

logaddexp(x1, x2, /, out=None, *, where=True, casting='same_kind',
order='K', dtype=None, subok=True[, signature, extobj])

Logarithm of the sum of exponentiations of the inputs.

Calculates ``log(exp(x1) + exp(x2))``. This function is useful in

 statistics where the calculated probabilities of events may be so small
as to exceed the range of normal floating point numbers. In such cases
the logarithm of the calculated probability is stored. This function
allows adding probabilities stored in such a fashion.

Parameters
----------
x1, x2 : array_like
Input values.
If ``x1.shape != x2.shape``, they must be broadcastable to a common
shape (which becomes the shape of the output).
out : ndarray, None, or tuple of ndarray and None, optional
A location into which the result is stored. If provided, it must have
a shape that the inputs broadcast to. If not provided or None,
a freshly-allocated array is returned. A tuple (possible only as a
keyword argument) must have length equal to the number of outputs.
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
-------
result : ndarray
Logarithm of ``exp(x1) + exp(x2)``.
This is a scalar if both `x1` and `x2` are scalars.

See Also
--------
logaddexp2: Logarithm of the sum of exponentiations of inputs in base 2.

Notes
-----
.. versionadded:: 1.3.0

Examples
--------
>>> prob1 = np.log(1e-50)
>>> prob2 = np.log(2.5e-50)
>>> prob12 = np.logaddexp(prob1, prob2)
>>> prob12
-113.87649168120691
>>> np.exp(prob12)
3.5000000000000057e-50

logaddexp2 = <ufunc 'logaddexp2'>

logaddexp2(x1, x2, /, out=None, *, where=True, casting='same_kind',
order='K', dtype=None, subok=True[, signature, extobj])

Logarithm of the sum of exponentiations of the inputs in base-2.

Calculates ``log2(2**x1 + 2**x2)``. This function is useful in machine

learning when the calculated probabilities of events may be so small as
 to exceed the range of normal floating point numbers. In such cases
the base-2 logarithm of the calculated probability can be used instead.
This function allows adding probabilities stored in such a fashion.

Parameters
----------
x1, x2 : array_like
Input values.
If ``x1.shape != x2.shape``, they must be broadcastable to a common
shape (which becomes the shape of the output).
out : ndarray, None, or tuple of ndarray and None, optional
A location into which the result is stored. If provided, it must have
a shape that the inputs broadcast to. If not provided or None,
a freshly-allocated array is returned. A tuple (possible only as a
keyword argument) must have length equal to the number of outputs.
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
-------
result : ndarray
Base-2 logarithm of ``2**x1 + 2**x2``.
This is a scalar if both `x1` and `x2` are scalars.

See Also
--------
logaddexp: Logarithm of the sum of exponentiations of the inputs.

Notes
-----
.. versionadded:: 1.3.0

Examples
--------
>>> prob1 = np.log2(1e-50)
>>> prob2 = np.log2(2.5e-50)
>>> prob12 = np.logaddexp2(prob1, prob2)
>>> prob1, prob2, prob12
(-166.09640474436813, -164.77447664948076, -164.28904982231052)
>>> 2**prob12
3.4999999999999914e-50

logical_and = <ufunc 'logical_and'>

logical_and(x1, x2, /, out=None, *, where=True, casting='same_kind',
order='K', dtype=None, subok=True[, signature, extobj])

Compute the truth value of x1 AND x2 element-wise.

Parameters
----------
x1, x2 : array_like
 Input arrays.
If ``x1.shape != x2.shape``, they must be broadcastable to a common
shape (which becomes the shape of the output).
out : ndarray, None, or tuple of ndarray and None, optional
A location into which the result is stored. If provided, it must have
a shape that the inputs broadcast to. If not provided or None,
a freshly-allocated array is returned. A tuple (possible only as a
keyword argument) must have length equal to the number of outputs.
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
-------
y : ndarray or bool
Boolean result of the logical AND operation applied to the elements
of `x1` and `x2`; the shape is determined by broadcasting.
This is a scalar if both `x1` and `x2` are scalars.

See Also
--------
logical_or, logical_not, logical_xor
bitwise_and

Examples
--------
>>> np.logical_and(True, False)
False
>>> np.logical_and([True, False], [False, False])
array([False, False])

>>> x = np.arange(5)
>>> np.logical_and(x>1, x<4)
array([False, False, True, True, False])

The ``&`` operator can be used as a shorthand for ``np.logical_and`` on

boolean ndarrays.

>>> a = np.array([True, False])

>>> b = np.array([False, False])
>>> a & b
array([False, False])

logical_not = <ufunc 'logical_not'>

logical_not(x, /, out=None, *, where=True, casting='same_kind', order='K',
dtype=None, subok=True[, signature, extobj])

Compute the truth value of NOT x element-wise.

Parameters
----------
 x : array_like
Logical NOT is applied to the elements of `x`.
out : ndarray, None, or tuple of ndarray and None, optional
A location into which the result is stored. If provided, it must have
a shape that the inputs broadcast to. If not provided or None,
a freshly-allocated array is returned. A tuple (possible only as a
keyword argument) must have length equal to the number of outputs.
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
-------
y : bool or ndarray of bool
Boolean result with the same shape as `x` of the NOT operation
on elements of `x`.
This is a scalar if `x` is a scalar.

See Also
--------
logical_and, logical_or, logical_xor

Examples
--------
>>> np.logical_not(3)
False
>>> np.logical_not([True, False, 0, 1])
array([False, True, True, False])

>>> x = np.arange(5)
>>> np.logical_not(x<3)
array([False, False, False, True, True])

logical_or = <ufunc 'logical_or'>

logical_or(x1, x2, /, out=None, *, where=True, casting='same_kind',
order='K', dtype=None, subok=True[, signature, extobj])

Compute the truth value of x1 OR x2 element-wise.

Parameters
----------
x1, x2 : array_like
Logical OR is applied to the elements of `x1` and `x2`.
If ``x1.shape != x2.shape``, they must be broadcastable to a common
shape (which becomes the shape of the output).
out : ndarray, None, or tuple of ndarray and None, optional
A location into which the result is stored. If provided, it must have
a shape that the inputs broadcast to. If not provided or None,
a freshly-allocated array is returned. A tuple (possible only as a
keyword argument) must have length equal to the number of outputs.
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
-------
y : ndarray or bool
Boolean result of the logical OR operation applied to the elements
of `x1` and `x2`; the shape is determined by broadcasting.
This is a scalar if both `x1` and `x2` are scalars.

See Also
--------
logical_and, logical_not, logical_xor
bitwise_or

Examples
--------
>>> np.logical_or(True, False)
True
>>> np.logical_or([True, False], [False, False])
array([ True, False])

>>> x = np.arange(5)
>>> np.logical_or(x < 1, x > 3)
array([ True, False, False, False, True])

The ``|`` operator can be used as a shorthand for ``np.logical_or`` on

boolean ndarrays.

>>> a = np.array([True, False])

>>> b = np.array([False, False])
>>> a | b
array([ True, False])

logical_xor = <ufunc 'logical_xor'>

logical_xor(x1, x2, /, out=None, *, where=True, casting='same_kind',
order='K', dtype=None, subok=True[, signature, extobj])

Compute the truth value of x1 XOR x2, element-wise.

Parameters
----------
x1, x2 : array_like
Logical XOR is applied to the elements of `x1` and `x2`.
If ``x1.shape != x2.shape``, they must be broadcastable to a common
shape (which becomes the shape of the output).
out : ndarray, None, or tuple of ndarray and None, optional
A location into which the result is stored. If provided, it must have
a shape that the inputs broadcast to. If not provided or None,
a freshly-allocated array is returned. A tuple (possible only as a
keyword argument) must have length equal to the number of outputs.
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
-------
y : bool or ndarray of bool
Boolean result of the logical XOR operation applied to the elements
of `x1` and `x2`; the shape is determined by broadcasting.
This is a scalar if both `x1` and `x2` are scalars.

See Also
--------
logical_and, logical_or, logical_not, bitwise_xor

Examples
--------
>>> np.logical_xor(True, False)
True
>>> np.logical_xor([True, True, False, False], [True, False, True, False])
array([False, True, True, False])

>>> x = np.arange(5)
>>> np.logical_xor(x < 1, x > 3)
array([ True, False, False, False, True])

Simple example showing support of broadcasting

>>> np.logical_xor(0, np.eye(2))

array([[ True, False],
[False, True]])

matmul = <ufunc 'matmul'>

matmul(x1, x2, /, out=None, *, casting='same_kind', order='K', dtype=None,
subok=True[, signature, extobj, axes, axis])

Matrix product of two arrays.

Parameters
----------
x1, x2 : array_like
Input arrays, scalars not allowed.
out : ndarray, optional
A location into which the result is stored. If provided, it must have
a shape that matches the signature `(n,k),(k,m)->(n,m)`. If not
provided or None, a freshly-allocated array is returned.
**kwargs
For other keyword-only arguments, see the
:ref:`ufunc docs <ufuncs.kwargs>`.

.. versionadded:: 1.16
Now handles ufunc kwargs

Returns
-------
y : ndarray
The matrix product of the inputs.
This is a scalar only when both x1, x2 are 1-d vectors.

Raises
------
ValueError
If the last dimension of `x1` is not the same size as
the second-to-last dimension of `x2`.

If a scalar value is passed in.

See Also
--------
vdot : Complex-conjugating dot product.
tensordot : Sum products over arbitrary axes.
einsum : Einstein summation convention.
dot : alternative matrix product with different broadcasting rules.

Notes
-----

The behavior depends on the arguments in the following way.

- If both arguments are 2-D they are multiplied like conventional

matrices.
- If either argument is N-D, N > 2, it is treated as a stack of
matrices residing in the last two indexes and broadcast accordingly.
- If the first argument is 1-D, it is promoted to a matrix by
prepending a 1 to its dimensions. After matrix multiplication
the prepended 1 is removed.
- If the second argument is 1-D, it is promoted to a matrix by
appending a 1 to its dimensions. After matrix multiplication
the appended 1 is removed.

``matmul`` differs from ``dot`` in two important ways:

- Multiplication by scalars is not allowed, use ``*`` instead.

- Stacks of matrices are broadcast together as if the matrices
were elements, respecting the signature ``(n,k),(k,m)->(n,m)``:

>>> a = np.ones([9, 5, 7, 4])

>>> c = np.ones([9, 5, 4, 3])
>>> np.dot(a, c).shape
(9, 5, 7, 9, 5, 3)
>>> np.matmul(a, c).shape
(9, 5, 7, 3)
>>> # n is 7, k is 4, m is 3

The matmul function implements the semantics of the ``@`` operator

introduced in Python 3.5 following :pep:`465`.

It uses an optimized BLAS library when possible (see `numpy.linalg`).

Examples
--------
For 2-D arrays it is the matrix product:
 >>> a = np.array([[1, 0],
... [0, 1]])
>>> b = np.array([[4, 1],
... [2, 2]])
>>> np.matmul(a, b)
array([[4, 1],
[2, 2]])

For 2-D mixed with 1-D, the result is the usual.

>>> a = np.array([[1, 0],

... [0, 1]])
>>> b = np.array([1, 2])
>>> np.matmul(a, b)
array([1, 2])
>>> np.matmul(b, a)
array([1, 2])

Broadcasting is conventional for stacks of arrays

>>> a = np.arange(2 * 2 * 4).reshape((2, 2, 4))

>>> b = np.arange(2 * 2 * 4).reshape((2, 4, 2))
>>> np.matmul(a,b).shape
(2, 2, 2)
>>> np.matmul(a, b)[0, 1, 1]
98
>>> sum(a[0, 1, :] * b[0 , :, 1])
98

Vector, vector returns the scalar inner product, but neither argument
is complex-conjugated:

>>> np.matmul([2j, 3j], [2j, 3j])

(-13+0j)

Scalar multiplication raises an error.

>>> np.matmul([1,2], 3)
Traceback (most recent call last):
...
ValueError: matmul: Input operand 1 does not have enough dimensions ...

The ``@`` operator can be used as a shorthand for ``np.matmul`` on

ndarrays.

>>> x1 = np.array([2j, 3j])

>>> x2 = np.array([2j, 3j])
>>> x1 @ x2
(-13+0j)

.. versionadded:: 1.10.0

maximum = <ufunc 'maximum'>

maximum(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K',
dtype=None, subok=True[, signature, extobj])

Element-wise maximum of array elements.

Compare two arrays and return a new array containing the element-wise
maxima. If one of the elements being compared is a NaN, then that
element is returned. If both elements are NaNs then the first is
returned. The latter distinction is important for complex NaNs, which
are defined as at least one of the real or imaginary parts being a NaN.
The net effect is that NaNs are propagated.

Parameters
----------
x1, x2 : array_like
The arrays holding the elements to be compared.
If ``x1.shape != x2.shape``, they must be broadcastable to a common
shape (which becomes the shape of the output).
out : ndarray, None, or tuple of ndarray and None, optional
A location into which the result is stored. If provided, it must have
a shape that the inputs broadcast to. If not provided or None,
a freshly-allocated array is returned. A tuple (possible only as a
keyword argument) must have length equal to the number of outputs.
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
-------
y : ndarray or scalar
The maximum of `x1` and `x2`, element-wise.
This is a scalar if both `x1` and `x2` are scalars.

See Also
--------
minimum :
Element-wise minimum of two arrays, propagates NaNs.
fmax :
Element-wise maximum of two arrays, ignores NaNs.
amax :
The maximum value of an array along a given axis, propagates NaNs.
nanmax :
The maximum value of an array along a given axis, ignores NaNs.

fmin, amin, nanmin

Notes
-----
The maximum is equivalent to ``np.where(x1 >= x2, x1, x2)`` when
neither x1 nor x2 are nans, but it is faster and does proper
broadcasting.

Examples
--------
>>> np.maximum([2, 3, 4], [1, 5, 2])
array([2, 5, 4])
 >>> np.maximum(np.eye(2), [0.5, 2]) # broadcasting
array([[ 1. , 2. ],
[ 0.5, 2. ]])

>>> np.maximum([np.nan, 0, np.nan], [0, np.nan, np.nan])

array([nan, nan, nan])
>>> np.maximum(np.Inf, 1)
inf

mgrid = <numpy.lib.index_tricks.MGridClass object>

minimum = <ufunc 'minimum'>
minimum(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K',
dtype=None, subok=True[, signature, extobj])

Element-wise minimum of array elements.

Compare two arrays and return a new array containing the element-wise
minima. If one of the elements being compared is a NaN, then that
element is returned. If both elements are NaNs then the first is
returned. The latter distinction is important for complex NaNs, which
are defined as at least one of the real or imaginary parts being a NaN.
The net effect is that NaNs are propagated.

Parameters
----------
x1, x2 : array_like
The arrays holding the elements to be compared.
If ``x1.shape != x2.shape``, they must be broadcastable to a common
shape (which becomes the shape of the output).
out : ndarray, None, or tuple of ndarray and None, optional
A location into which the result is stored. If provided, it must have
a shape that the inputs broadcast to. If not provided or None,
a freshly-allocated array is returned. A tuple (possible only as a
keyword argument) must have length equal to the number of outputs.
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
-------
y : ndarray or scalar
The minimum of `x1` and `x2`, element-wise.
This is a scalar if both `x1` and `x2` are scalars.

See Also
--------
maximum :
Element-wise maximum of two arrays, propagates NaNs.
fmin :
Element-wise minimum of two arrays, ignores NaNs.
amin :
The minimum value of an array along a given axis, propagates NaNs.
 nanmin :
The minimum value of an array along a given axis, ignores NaNs.

fmax, amax, nanmax

Notes
-----
The minimum is equivalent to ``np.where(x1 <= x2, x1, x2)`` when
neither x1 nor x2 are NaNs, but it is faster and does proper
broadcasting.

Examples
--------
>>> np.minimum([2, 3, 4], [1, 5, 2])
array([1, 3, 2])

>>> np.minimum(np.eye(2), [0.5, 2]) # broadcasting

array([[ 0.5, 0. ],
[ 0. , 1. ]])

>>> np.minimum([np.nan, 0, np.nan],[0, np.nan, np.nan])

array([nan, nan, nan])
>>> np.minimum(-np.Inf, 1)
-inf

mod = <ufunc 'remainder'>

remainder(x1, x2, /, out=None, *, where=True, casting='same_kind',
order='K', dtype=None, subok=True[, signature, extobj])

Returns the element-wise remainder of division.

Computes the remainder complementary to the `floor_divide` function. It is

equivalent to the Python modulus operator``x1 % x2`` and has the same sign
as the divisor `x2`. The MATLAB function equivalent to ``np.remainder``
is ``mod``.

.. warning::

This should not be confused with:

* Python 3.7's `math.remainder` and C's ``remainder``, which

computes the IEEE remainder, which are the complement to
``round(x1 / x2)``.
* The MATLAB ``rem`` function and or the C ``%`` operator which is the
complement to ``int(x1 / x2)``.

Parameters
----------
x1 : array_like
Dividend array.
x2 : array_like
Divisor array.
If ``x1.shape != x2.shape``, they must be broadcastable to a common
shape (which becomes the shape of the output).
out : ndarray, None, or tuple of ndarray and None, optional
A location into which the result is stored. If provided, it must have
a shape that the inputs broadcast to. If not provided or None,
a freshly-allocated array is returned. A tuple (possible only as a
keyword argument) must have length equal to the number of outputs.
 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
-------
y : ndarray
The element-wise remainder of the quotient ``floor_divide(x1, x2)``.
This is a scalar if both `x1` and `x2` are scalars.

See Also
--------
floor_divide : Equivalent of Python ``//`` operator.
divmod : Simultaneous floor division and remainder.
fmod : Equivalent of the MATLAB ``rem`` function.
divide, floor

Notes
-----
Returns 0 when `x2` is 0 and both `x1` and `x2` are (arrays of)
integers.
``mod`` is an alias of ``remainder``.

Examples
--------
>>> np.remainder([4, 7], [2, 3])
array([0, 1])
>>> np.remainder(np.arange(7), 5)
array([0, 1, 2, 3, 4, 0, 1])

The ``%`` operator can be used as a shorthand for ``np.remainder`` on

ndarrays.

>>> x1 = np.arange(7)
>>> x1 % 5
array([0, 1, 2, 3, 4, 0, 1])

modf = <ufunc 'modf'>

modf(x[, out1, out2], / [, out=(None, None)], *, where=True,
casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])

Return the fractional and integral parts of an array, element-wise.

The fractional and integral parts are negative if the given number is
negative.

Parameters
----------
x : array_like
Input array.
out : ndarray, None, or tuple of ndarray and None, optional
A location into which the result is stored. If provided, it must have
 a shape that the inputs broadcast to. If not provided or None,
a freshly-allocated array is returned. A tuple (possible only as a
keyword argument) must have length equal to the number of outputs.
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
-------
y1 : ndarray
Fractional part of `x`.
This is a scalar if `x` is a scalar.
y2 : ndarray
Integral part of `x`.
This is a scalar if `x` is a scalar.

Notes
-----
For integer input the return values are floats.

See Also
--------
divmod : ``divmod(x, 1)`` is equivalent to ``modf`` with the return values
switched, except it always has a positive remainder.

Examples
--------
>>> np.modf([0, 3.5])
(array([ 0. , 0.5]), array([ 0., 3.]))
>>> np.modf(-0.5)
(-0.5, -0)

multiply = <ufunc 'multiply'>

multiply(x1, x2, /, out=None, *, where=True, casting='same_kind',
order='K', dtype=None, subok=True[, signature, extobj])

Multiply arguments element-wise.

Parameters
----------
x1, x2 : array_like
Input arrays to be multiplied.
If ``x1.shape != x2.shape``, they must be broadcastable to a common
shape (which becomes the shape of the output).
out : ndarray, None, or tuple of ndarray and None, optional
A location into which the result is stored. If provided, it must have
a shape that the inputs broadcast to. If not provided or None,
a freshly-allocated array is returned. A tuple (possible only as a
keyword argument) must have length equal to the number of outputs.
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
-------
y : ndarray
The product of `x1` and `x2`, element-wise.
This is a scalar if both `x1` and `x2` are scalars.

Notes
-----
Equivalent to `x1` * `x2` in terms of array broadcasting.

Examples
--------
>>> np.multiply(2.0, 4.0)
8.0

>>> x1 = np.arange(9.0).reshape((3, 3))

>>> x2 = np.arange(3.0)
>>> np.multiply(x1, x2)
array([[ 0., 1., 4.],
[ 0., 4., 10.],
[ 0., 7., 16.]])

The ``*`` operator can be used as a shorthand for ``np.multiply`` on

ndarrays.

>>> x1 = np.arange(9.0).reshape((3, 3))

>>> x2 = np.arange(3.0)
>>> x1 * x2
array([[ 0., 1., 4.],
[ 0., 4., 10.],
[ 0., 7., 16.]])

nan = nan
nbytes = {<class 'numpy.bool_'>: 1, <class 'numpy.int8'>:....datetime6...
negative = <ufunc 'negative'>
negative(x, /, out=None, *, where=True, casting='same_kind', order='K',
dtype=None, subok=True[, signature, extobj])

Numerical negative, element-wise.

Parameters
----------
x : array_like or scalar
Input array.
out : ndarray, None, or tuple of ndarray and None, optional
A location into which the result is stored. If provided, it must have
a shape that the inputs broadcast to. If not provided or None,
a freshly-allocated array is returned. A tuple (possible only as a
keyword argument) must have length equal to the number of outputs.
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
-------
y : ndarray or scalar
Returned array or scalar: `y = -x`.
This is a scalar if `x` is a scalar.

Examples
--------
>>> np.negative([1.,-1.])
array([-1., 1.])

The unary ``-`` operator can be used as a shorthand for ``np.negative`` on

ndarrays.

>>> x1 = np.array(([1., -1.]))

>>> -x1
array([-1., 1.])

newaxis = None
nextafter = <ufunc 'nextafter'>
nextafter(x1, x2, /, out=None, *, where=True, casting='same_kind',
order='K', dtype=None, subok=True[, signature, extobj])

Return the next floating-point value after x1 towards x2, element-wise.

Parameters
----------
x1 : array_like
Values to find the next representable value of.
x2 : array_like
The direction where to look for the next representable value of `x1`.
If ``x1.shape != x2.shape``, they must be broadcastable to a common
shape (which becomes the shape of the output).
out : ndarray, None, or tuple of ndarray and None, optional
A location into which the result is stored. If provided, it must have
a shape that the inputs broadcast to. If not provided or None,
a freshly-allocated array is returned. A tuple (possible only as a
keyword argument) must have length equal to the number of outputs.
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
 -------
out : ndarray or scalar
The next representable values of `x1` in the direction of `x2`.
This is a scalar if both `x1` and `x2` are scalars.

Examples
--------
>>> eps = np.finfo(np.float64).eps
>>> np.nextafter(1, 2) == eps + 1
True
>>> np.nextafter([1, 2], [2, 1]) == [eps + 1, 2 - eps]
array([ True, True])

not_equal = <ufunc 'not_equal'>

not_equal(x1, x2, /, out=None, *, where=True, casting='same_kind',
order='K', dtype=None, subok=True[, signature, extobj])

Return (x1 != x2) element-wise.

Parameters
----------
x1, x2 : array_like
Input arrays.
If ``x1.shape != x2.shape``, they must be broadcastable to a common
shape (which becomes the shape of the output).
out : ndarray, None, or tuple of ndarray and None, optional
A location into which the result is stored. If provided, it must have
a shape that the inputs broadcast to. If not provided or None,
a freshly-allocated array is returned. A tuple (possible only as a
keyword argument) must have length equal to the number of outputs.
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
-------
out : ndarray or scalar
Output array, element-wise comparison of `x1` and `x2`.
Typically of type bool, unless ``dtype=object`` is passed.
This is a scalar if both `x1` and `x2` are scalars.

See Also
--------
equal, greater, greater_equal, less, less_equal

Examples
--------
>>> np.not_equal([1.,2.], [1., 3.])
array([False, True])
>>> np.not_equal([1, 2], [[1, 3],[1, 4]])
array([[False, True],
[False, True]])
 The ``!=`` operator can be used as a shorthand for ``np.not_equal`` on
ndarrays.

>>> a = np.array([1., 2.])

>>> b = np.array([1., 3.])
>>> a != b
array([False, True])

ogrid = <numpy.lib.index_tricks.OGridClass object>

pi = 3.141592653589793
positive = <ufunc 'positive'>
positive(x, /, out=None, *, where=True, casting='same_kind', order='K',
dtype=None, subok=True[, signature, extobj])

Numerical positive, element-wise.

.. versionadded:: 1.13.0

Parameters
----------
x : array_like or scalar
Input array.

Returns
-------
y : ndarray or scalar
Returned array or scalar: `y = +x`.
This is a scalar if `x` is a scalar.

Notes
-----
Equivalent to `x.copy()`, but only defined for types that support
arithmetic.

Examples
--------

>>> x1 = np.array(([1., -1.]))

>>> np.positive(x1)
array([ 1., -1.])

The unary ``+`` operator can be used as a shorthand for ``np.positive`` on

ndarrays.

>>> x1 = np.array(([1., -1.]))

>>> +x1
array([ 1., -1.])

power = <ufunc 'power'>

power(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K',
dtype=None, subok=True[, signature, extobj])

First array elements raised to powers from second array, element-wise.

Raise each base in `x1` to the positionally-corresponding power in

`x2`. `x1` and `x2` must be broadcastable to the same shape.

An integer type raised to a negative integer power will raise a

``ValueError``.

Negative values raised to a non-integral value will return ``nan``.

To get complex results, cast the input to complex, or specify the
``dtype`` to be ``complex`` (see the example below).

Parameters
----------
x1 : array_like
The bases.
x2 : array_like
The exponents.
If ``x1.shape != x2.shape``, they must be broadcastable to a common
shape (which becomes the shape of the output).
out : ndarray, None, or tuple of ndarray and None, optional
A location into which the result is stored. If provided, it must have
a shape that the inputs broadcast to. If not provided or None,
a freshly-allocated array is returned. A tuple (possible only as a
keyword argument) must have length equal to the number of outputs.
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
-------
y : ndarray
The bases in `x1` raised to the exponents in `x2`.
This is a scalar if both `x1` and `x2` are scalars.

See Also
--------
float_power : power function that promotes integers to float

Examples
--------
Cube each element in an array.

>>> x1 = np.arange(6)
>>> x1
[0, 1, 2, 3, 4, 5]
>>> np.power(x1, 3)
array([ 0, 1, 8, 27, 64, 125])

Raise the bases to different exponents.

>>> x2 = [1.0, 2.0, 3.0, 3.0, 2.0, 1.0]

>>> np.power(x1, x2)
array([ 0., 1., 8., 27., 16., 5.])

The effect of broadcasting.

>>> x2 = np.array([[1, 2, 3, 3, 2, 1], [1, 2, 3, 3, 2, 1]])

 >>> x2
array([[1, 2, 3, 3, 2, 1],
[1, 2, 3, 3, 2, 1]])
>>> np.power(x1, x2)
array([[ 0, 1, 8, 27, 16, 5],
[ 0, 1, 8, 27, 16, 5]])

The ``**`` operator can be used as a shorthand for ``np.power`` on

ndarrays.

>>> x2 = np.array([1, 2, 3, 3, 2, 1])

>>> x1 = np.arange(6)
>>> x1 ** x2
array([ 0, 1, 8, 27, 16, 5])

Negative values raised to a non-integral value will result in ``nan``

(and a warning will be generated).

>>> x3 = np.array([-1.0, -4.0])

>>> with np.errstate(invalid='ignore'):
... p = np.power(x3, 1.5)
...
>>> p
array([nan, nan])

To get complex results, give the argument ``dtype=complex``.

>>> np.power(x3, 1.5, dtype=complex)

array([-1.83697020e-16-1.j, -1.46957616e-15-8.j])

r_ = <numpy.lib.index_tricks.RClass object>
rad2deg = <ufunc 'rad2deg'>
rad2deg(x, /, out=None, *, where=True, casting='same_kind', order='K',
dtype=None, subok=True[, signature, extobj])

Convert angles from radians to degrees.

Parameters
----------
x : array_like
Angle in radians.
out : ndarray, None, or tuple of ndarray and None, optional
A location into which the result is stored. If provided, it must have
a shape that the inputs broadcast to. If not provided or None,
a freshly-allocated array is returned. A tuple (possible only as a
keyword argument) must have length equal to the number of outputs.
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
-------
 y : ndarray
The corresponding angle in degrees.
This is a scalar if `x` is a scalar.

See Also
--------
deg2rad : Convert angles from degrees to radians.
unwrap : Remove large jumps in angle by wrapping.

Notes
-----
.. versionadded:: 1.3.0

rad2deg(x) is ``180 * x / pi``.

Examples
--------
>>> np.rad2deg(np.pi/2)
90.0

radians = <ufunc 'radians'>

radians(x, /, out=None, *, where=True, casting='same_kind', order='K',
dtype=None, subok=True[, signature, extobj])

Convert angles from degrees to radians.

Parameters
----------
x : array_like
Input array in degrees.
out : ndarray, None, or tuple of ndarray and None, optional
A location into which the result is stored. If provided, it must have
a shape that the inputs broadcast to. If not provided or None,
a freshly-allocated array is returned. A tuple (possible only as a
keyword argument) must have length equal to the number of outputs.
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
-------
y : ndarray
The corresponding radian values.
This is a scalar if `x` is a scalar.

See Also
--------
deg2rad : equivalent function

Examples
--------
Convert a degree array to radians
 >>> deg = np.arange(12.) * 30.
>>> np.radians(deg)
array([ 0. , 0.52359878, 1.04719755, 1.57079633, 2.0943951 ,
2.61799388, 3.14159265, 3.66519143, 4.1887902 , 4.71238898,
5.23598776, 5.75958653])

>>> out = np.zeros((deg.shape))

>>> ret = np.radians(deg, out)
>>> ret is out
True

reciprocal = <ufunc 'reciprocal'>

reciprocal(x, /, out=None, *, where=True, casting='same_kind', order='K',
dtype=None, subok=True[, signature, extobj])

Return the reciprocal of the argument, element-wise.

Calculates ``1/x``.

Parameters
----------
x : array_like
Input array.
out : ndarray, None, or tuple of ndarray and None, optional
A location into which the result is stored. If provided, it must have
a shape that the inputs broadcast to. If not provided or None,
a freshly-allocated array is returned. A tuple (possible only as a
keyword argument) must have length equal to the number of outputs.
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
-------
y : ndarray
Return array.
This is a scalar if `x` is a scalar.

Notes
-----
.. note::
This function is not designed to work with integers.

For integer arguments with absolute value larger than 1 the result is
always zero because of the way Python handles integer division. For
integer zero the result is an overflow.

Examples
--------
>>> np.reciprocal(2.)
0.5
 >>> np.reciprocal([1, 2., 3.33])
array([ 1. , 0.5 , 0.3003003])

remainder = <ufunc 'remainder'>

remainder(x1, x2, /, out=None, *, where=True, casting='same_kind',
order='K', dtype=None, subok=True[, signature, extobj])

Returns the element-wise remainder of division.

Computes the remainder complementary to the `floor_divide` function. It is

equivalent to the Python modulus operator``x1 % x2`` and has the same sign
as the divisor `x2`. The MATLAB function equivalent to ``np.remainder``
is ``mod``.

.. warning::

This should not be confused with:

* Python 3.7's `math.remainder` and C's ``remainder``, which

computes the IEEE remainder, which are the complement to
``round(x1 / x2)``.
* The MATLAB ``rem`` function and or the C ``%`` operator which is the
complement to ``int(x1 / x2)``.

Parameters
----------
x1 : array_like
Dividend array.
x2 : array_like
Divisor array.
If ``x1.shape != x2.shape``, they must be broadcastable to a common
shape (which becomes the shape of the output).
out : ndarray, None, or tuple of ndarray and None, optional
A location into which the result is stored. If provided, it must have
a shape that the inputs broadcast to. If not provided or None,
a freshly-allocated array is returned. A tuple (possible only as a
keyword argument) must have length equal to the number of outputs.
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
-------
y : ndarray
The element-wise remainder of the quotient ``floor_divide(x1, x2)``.
This is a scalar if both `x1` and `x2` are scalars.

See Also
--------
floor_divide : Equivalent of Python ``//`` operator.
divmod : Simultaneous floor division and remainder.
fmod : Equivalent of the MATLAB ``rem`` function.
 divide, floor

Notes
-----
Returns 0 when `x2` is 0 and both `x1` and `x2` are (arrays of)
integers.
``mod`` is an alias of ``remainder``.

Examples
--------
>>> np.remainder([4, 7], [2, 3])
array([0, 1])
>>> np.remainder(np.arange(7), 5)
array([0, 1, 2, 3, 4, 0, 1])

The ``%`` operator can be used as a shorthand for ``np.remainder`` on

ndarrays.

>>> x1 = np.arange(7)
>>> x1 % 5
array([0, 1, 2, 3, 4, 0, 1])

right_shift = <ufunc 'right_shift'>

right_shift(x1, x2, /, out=None, *, where=True, casting='same_kind',
order='K', dtype=None, subok=True[, signature, extobj])

Shift the bits of an integer to the right.

Bits are shifted to the right `x2`. Because the internal

representation of numbers is in binary format, this operation is
equivalent to dividing `x1` by ``2**x2``.

Parameters
----------
x1 : array_like, int
Input values.
x2 : array_like, int
Number of bits to remove at the right of `x1`.
If ``x1.shape != x2.shape``, they must be broadcastable to a common
shape (which becomes the shape of the output).
out : ndarray, None, or tuple of ndarray and None, optional
A location into which the result is stored. If provided, it must have
a shape that the inputs broadcast to. If not provided or None,
a freshly-allocated array is returned. A tuple (possible only as a
keyword argument) must have length equal to the number of outputs.
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
-------
out : ndarray, int
 Return `x1` with bits shifted `x2` times to the right.
This is a scalar if both `x1` and `x2` are scalars.

See Also
--------
left_shift : Shift the bits of an integer to the left.
binary_repr : Return the binary representation of the input number
as a string.

Examples
--------
>>> np.binary_repr(10)
'1010'
>>> np.right_shift(10, 1)
5
>>> np.binary_repr(5)
'101'

>>> np.right_shift(10, [1,2,3])

array([5, 2, 1])

The ``>>`` operator can be used as a shorthand for ``np.right_shift`` on

ndarrays.

>>> x1 = 10
>>> x2 = np.array([1,2,3])
>>> x1 >> x2
array([5, 2, 1])

rint = <ufunc 'rint'>

rint(x, /, out=None, *, where=True, casting='same_kind', order='K',
dtype=None, subok=True[, signature, extobj])

Round elements of the array to the nearest integer.

Parameters
----------
x : array_like
Input array.
out : ndarray, None, or tuple of ndarray and None, optional
A location into which the result is stored. If provided, it must have
a shape that the inputs broadcast to. If not provided or None,
a freshly-allocated array is returned. A tuple (possible only as a
keyword argument) must have length equal to the number of outputs.
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
-------
out : ndarray or scalar
Output array is same shape and type as `x`.
 This is a scalar if `x` is a scalar.

See Also
--------
fix, ceil, floor, trunc

Notes
-----
For values exactly halfway between rounded decimal values, NumPy
rounds to the nearest even value. Thus 1.5 and 2.5 round to 2.0,
-0.5 and 0.5 round to 0.0, etc.

Examples
--------
>>> a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0])
>>> np.rint(a)
array([-2., -2., -0., 0., 2., 2., 2.])

s_ = <numpy.lib.index_tricks.IndexExpression object>
sctypeDict = {'?': <class 'numpy.bool_'>, 0: <class 'numpy.bool_'>, 'b...
sctypes = {'complex': [<class 'numpy.complex64'>, <class 'numpy.comple...
sign = <ufunc 'sign'>
sign(x, /, out=None, *, where=True, casting='same_kind', order='K',
dtype=None, subok=True[, signature, extobj])

Returns an element-wise indication of the sign of a number.

The `sign` function returns ``-1 if x < 0, 0 if x==0, 1 if x > 0``. nan
is returned for nan inputs.

For complex inputs, the `sign` function returns

``sign(x.real) + 0j if x.real != 0 else sign(x.imag) + 0j``.

complex(nan, 0) is returned for complex nan inputs.

Parameters
----------
x : array_like
Input values.
out : ndarray, None, or tuple of ndarray and None, optional
A location into which the result is stored. If provided, it must have
a shape that the inputs broadcast to. If not provided or None,
a freshly-allocated array is returned. A tuple (possible only as a
keyword argument) must have length equal to the number of outputs.
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
-------
y : ndarray
The sign of `x`.
 This is a scalar if `x` is a scalar.

Notes
-----
There is more than one definition of sign in common use for complex
numbers. The definition used here is equivalent to :math:`x/\sqrt{x*x}`
which is different from a common alternative, :math:`x/|x|`.

Examples
--------
>>> np.sign([-5., 4.5])
array([-1., 1.])
>>> np.sign(0)
0
>>> np.sign(5-2j)
(1+0j)

signbit = <ufunc 'signbit'>

signbit(x, /, out=None, *, where=True, casting='same_kind', order='K',
dtype=None, subok=True[, signature, extobj])

Returns element-wise True where signbit is set (less than zero).

Parameters
----------
x : array_like
The input value(s).
out : ndarray, None, or tuple of ndarray and None, optional
A location into which the result is stored. If provided, it must have
a shape that the inputs broadcast to. If not provided or None,
a freshly-allocated array is returned. A tuple (possible only as a
keyword argument) must have length equal to the number of outputs.
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
-------
result : ndarray of bool
Output array, or reference to `out` if that was supplied.
This is a scalar if `x` is a scalar.

Examples
--------
>>> np.signbit(-1.2)
True
>>> np.signbit(np.array([1, -2.3, 2.1]))
array([False, True, False])

sin = <ufunc 'sin'>

sin(x, /, out=None, *, where=True, casting='same_kind', order='K',
dtype=None, subok=True[, signature, extobj])
Trigonometric sine, element-wise.

Parameters
----------
x : array_like
Angle, in radians (:math:`2 \pi` rad equals 360 degrees).
out : ndarray, None, or tuple of ndarray and None, optional
A location into which the result is stored. If provided, it must have
a shape that the inputs broadcast to. If not provided or None,
a freshly-allocated array is returned. A tuple (possible only as a
keyword argument) must have length equal to the number of outputs.
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
-------
y : array_like
The sine of each element of x.
This is a scalar if `x` is a scalar.

See Also
--------
arcsin, sinh, cos

Notes
-----
The sine is one of the fundamental functions of trigonometry (the
mathematical study of triangles). Consider a circle of radius 1
centered on the origin. A ray comes in from the :math:`+x` axis, makes
an angle at the origin (measured counter-clockwise from that axis), and
departs from the origin. The :math:`y` coordinate of the outgoing
ray's intersection with the unit circle is the sine of that angle. It
ranges from -1 for :math:`x=3\pi / 2` to +1 for :math:`\pi / 2.` The
function has zeroes where the angle is a multiple of :math:`\pi`.
Sines of angles between :math:`\pi` and :math:`2\pi` are negative.
The numerous properties of the sine and related functions are included
in any standard trigonometry text.

Examples
--------
Print sine of one angle:

>>> np.sin(np.pi/2.)
1.0

Print sines of an array of angles given in degrees:

>>> np.sin(np.array((0., 30., 45., 60., 90.)) * np.pi / 180. )

array([ 0. , 0.5 , 0.70710678, 0.8660254 , 1. ])
 Plot the sine function:

>>> import matplotlib.pylab as plt

>>> x = np.linspace(-np.pi, np.pi, 201)
>>> plt.plot(x, np.sin(x))
>>> plt.xlabel('Angle [rad]')
>>> plt.ylabel('sin(x)')
>>> plt.axis('tight')
>>> plt.show()

sinh = <ufunc 'sinh'>

sinh(x, /, out=None, *, where=True, casting='same_kind', order='K',
dtype=None, subok=True[, signature, extobj])

Hyperbolic sine, element-wise.

Equivalent to ``1/2 * (np.exp(x) - np.exp(-x))`` or

``-1j * np.sin(1j*x)``.

Parameters
----------
x : array_like
Input array.
out : ndarray, None, or tuple of ndarray and None, optional
A location into which the result is stored. If provided, it must have
a shape that the inputs broadcast to. If not provided or None,
a freshly-allocated array is returned. A tuple (possible only as a
keyword argument) must have length equal to the number of outputs.
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
-------
y : ndarray
The corresponding hyperbolic sine values.
This is a scalar if `x` is a scalar.

Notes
-----
If `out` is provided, the function writes the result into it,
and returns a reference to `out`. (See Examples)

References
----------
M. Abramowitz and I. A. Stegun, Handbook of Mathematical Functions.
New York, NY: Dover, 1972, pg. 83.

Examples
--------
>>> np.sinh(0)
0.0
 >>> np.sinh(np.pi*1j/2)
1j
>>> np.sinh(np.pi*1j) # (exact value is 0)
1.2246063538223773e-016j
>>> # Discrepancy due to vagaries of floating point arithmetic.

>>> # Example of providing the optional output parameter

>>> out1 = np.array([0], dtype='d')
>>> out2 = np.sinh([0.1], out1)
>>> out2 is out1
True

>>> # Example of ValueError due to provision of shape mis-matched `out`

>>> np.sinh(np.zeros((3,3)),np.zeros((2,2)))
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: operands could not be broadcast together with shapes (3,3)
(2,2)

spacing = <ufunc 'spacing'>

spacing(x, /, out=None, *, where=True, casting='same_kind', order='K',
dtype=None, subok=True[, signature, extobj])

Return the distance between x and the nearest adjacent number.

Parameters
----------
x : array_like
Values to find the spacing of.
out : ndarray, None, or tuple of ndarray and None, optional
A location into which the result is stored. If provided, it must have
a shape that the inputs broadcast to. If not provided or None,
a freshly-allocated array is returned. A tuple (possible only as a
keyword argument) must have length equal to the number of outputs.
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
-------
out : ndarray or scalar
The spacing of values of `x`.
This is a scalar if `x` is a scalar.

Notes
-----
It can be considered as a generalization of EPS:
``spacing(np.float64(1)) == np.finfo(np.float64).eps``, and there
should not be any representable number between ``x + spacing(x)`` and
x for any finite x.

Spacing of +- inf and NaN is NaN.

 Examples
--------
>>> np.spacing(1) == np.finfo(np.float64).eps
True

sqrt = <ufunc 'sqrt'>

sqrt(x, /, out=None, *, where=True, casting='same_kind', order='K',
dtype=None, subok=True[, signature, extobj])

Return the non-negative square-root of an array, element-wise.

Parameters
----------
x : array_like
The values whose square-roots are required.
out : ndarray, None, or tuple of ndarray and None, optional
A location into which the result is stored. If provided, it must have
a shape that the inputs broadcast to. If not provided or None,
a freshly-allocated array is returned. A tuple (possible only as a
keyword argument) must have length equal to the number of outputs.
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
-------
y : ndarray
An array of the same shape as `x`, containing the positive
square-root of each element in `x`. If any element in `x` is
complex, a complex array is returned (and the square-roots of
negative reals are calculated). If all of the elements in `x`
are real, so is `y`, with negative elements returning ``nan``.
If `out` was provided, `y` is a reference to it.
This is a scalar if `x` is a scalar.

See Also
--------
emath.sqrt
A version which returns complex numbers when given negative reals.
Note that 0.0 and -0.0 are handled differently for complex inputs.

Notes
-----
*sqrt* has--consistent with common convention--as its branch cut the
real "interval" [`-inf`, 0), and is continuous from above on it.
A branch cut is a curve in the complex plane across which a given
complex function fails to be continuous.

Examples
--------
>>> np.sqrt([1,4,9])
 array([ 1., 2., 3.])

>>> np.sqrt([4, -1, -3+4J])

array([ 2.+0.j, 0.+1.j, 1.+2.j])

>>> np.sqrt([4, -1, np.inf])

array([ 2., nan, inf])

square = <ufunc 'square'>

square(x, /, out=None, *, where=True, casting='same_kind', order='K',
dtype=None, subok=True[, signature, extobj])

Return the element-wise square of the input.

Parameters
----------
x : array_like
Input data.
out : ndarray, None, or tuple of ndarray and None, optional
A location into which the result is stored. If provided, it must have
a shape that the inputs broadcast to. If not provided or None,
a freshly-allocated array is returned. A tuple (possible only as a
keyword argument) must have length equal to the number of outputs.
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
-------
out : ndarray or scalar
Element-wise `x*x`, of the same shape and dtype as `x`.
This is a scalar if `x` is a scalar.

See Also
--------
numpy.linalg.matrix_power
sqrt
power

Examples
--------
>>> np.square([-1j, 1])
array([-1.-0.j, 1.+0.j])

subtract = <ufunc 'subtract'>

subtract(x1, x2, /, out=None, *, where=True, casting='same_kind',
order='K', dtype=None, subok=True[, signature, extobj])

Subtract arguments, element-wise.

Parameters
----------
 x1, x2 : array_like
The arrays to be subtracted from each other.
If ``x1.shape != x2.shape``, they must be broadcastable to a common
shape (which becomes the shape of the output).
out : ndarray, None, or tuple of ndarray and None, optional
A location into which the result is stored. If provided, it must have
a shape that the inputs broadcast to. If not provided or None,
a freshly-allocated array is returned. A tuple (possible only as a
keyword argument) must have length equal to the number of outputs.
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
-------
y : ndarray
The difference of `x1` and `x2`, element-wise.
This is a scalar if both `x1` and `x2` are scalars.

Notes
-----
Equivalent to ``x1 - x2`` in terms of array broadcasting.

Examples
--------
>>> np.subtract(1.0, 4.0)
-3.0

>>> x1 = np.arange(9.0).reshape((3, 3))

>>> x2 = np.arange(3.0)
>>> np.subtract(x1, x2)
array([[ 0., 0., 0.],
[ 3., 3., 3.],
[ 6., 6., 6.]])

The ``-`` operator can be used as a shorthand for ``np.subtract`` on

ndarrays.

>>> x1 = np.arange(9.0).reshape((3, 3))

>>> x2 = np.arange(3.0)
>>> x1 - x2
array([[0., 0., 0.],
[3., 3., 3.],
[6., 6., 6.]])

tan = <ufunc 'tan'>

tan(x, /, out=None, *, where=True, casting='same_kind', order='K',
dtype=None, subok=True[, signature, extobj])

Compute tangent element-wise.

Equivalent to ``np.sin(x)/np.cos(x)`` element-wise.

 Parameters
----------
x : array_like
Input array.
out : ndarray, None, or tuple of ndarray and None, optional
A location into which the result is stored. If provided, it must have
a shape that the inputs broadcast to. If not provided or None,
a freshly-allocated array is returned. A tuple (possible only as a
keyword argument) must have length equal to the number of outputs.
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
-------
y : ndarray
The corresponding tangent values.
This is a scalar if `x` is a scalar.

Notes
-----
If `out` is provided, the function writes the result into it,
and returns a reference to `out`. (See Examples)

References
----------
M. Abramowitz and I. A. Stegun, Handbook of Mathematical Functions.
New York, NY: Dover, 1972.

Examples
--------
>>> from math import pi
>>> np.tan(np.array([-pi,pi/2,pi]))
array([ 1.22460635e-16, 1.63317787e+16, -1.22460635e-16])
>>>
>>> # Example of providing the optional output parameter illustrating
>>> # that what is returned is a reference to said parameter
>>> out1 = np.array([0], dtype='d')
>>> out2 = np.cos([0.1], out1)
>>> out2 is out1
True
>>>
>>> # Example of ValueError due to provision of shape mis-matched `out`
>>> np.cos(np.zeros((3,3)),np.zeros((2,2)))
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: operands could not be broadcast together with shapes (3,3)
(2,2)

tanh = <ufunc 'tanh'>

tanh(x, /, out=None, *, where=True, casting='same_kind', order='K',
dtype=None, subok=True[, signature, extobj])

Compute hyperbolic tangent element-wise.

Equivalent to ``np.sinh(x)/np.cosh(x)`` or ``-1j * np.tan(1j*x)``.

Parameters
----------
x : array_like
Input array.
out : ndarray, None, or tuple of ndarray and None, optional
A location into which the result is stored. If provided, it must have
a shape that the inputs broadcast to. If not provided or None,
a freshly-allocated array is returned. A tuple (possible only as a
keyword argument) must have length equal to the number of outputs.
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
-------
y : ndarray
The corresponding hyperbolic tangent values.
This is a scalar if `x` is a scalar.

Notes
-----
If `out` is provided, the function writes the result into it,
and returns a reference to `out`. (See Examples)

References
----------
.. [1] M. Abramowitz and I. A. Stegun, Handbook of Mathematical Functions.
New York, NY: Dover, 1972, pg. 83.
https://personal.math.ubc.ca/~cbm/aands/page_83.htm

.. [2] Wikipedia, "Hyperbolic function",

https://en.wikipedia.org/wiki/Hyperbolic_function

Examples
--------
>>> np.tanh((0, np.pi*1j, np.pi*1j/2))
array([ 0. +0.00000000e+00j, 0. -1.22460635e-16j, 0. +1.63317787e+16j])

>>> # Example of providing the optional output parameter illustrating

>>> # that what is returned is a reference to said parameter
>>> out1 = np.array([0], dtype='d')
>>> out2 = np.tanh([0.1], out1)
>>> out2 is out1
True

>>> # Example of ValueError due to provision of shape mis-matched `out`

 >>> np.tanh(np.zeros((3,3)),np.zeros((2,2)))
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: operands could not be broadcast together with shapes (3,3)
(2,2)

tracemalloc_domain = 389047
true_divide = <ufunc 'divide'>
divide(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K',
dtype=None, subok=True[, signature, extobj])

Divide arguments element-wise.

Parameters
----------
x1 : array_like
Dividend array.
x2 : array_like
Divisor array.
If ``x1.shape != x2.shape``, they must be broadcastable to a common
shape (which becomes the shape of the output).
out : ndarray, None, or tuple of ndarray and None, optional
A location into which the result is stored. If provided, it must have
a shape that the inputs broadcast to. If not provided or None,
a freshly-allocated array is returned. A tuple (possible only as a
keyword argument) must have length equal to the number of outputs.
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
-------
y : ndarray or scalar
The quotient ``x1/x2``, element-wise.
This is a scalar if both `x1` and `x2` are scalars.

See Also
--------
seterr : Set whether to raise or warn on overflow, underflow and
division by zero.

Notes
-----
Equivalent to ``x1`` / ``x2`` in terms of array-broadcasting.

The ``true_divide(x1, x2)`` function is an alias for

``divide(x1, x2)``.

Examples
--------
>>> np.divide(2.0, 4.0)
0.5
 >>> x1 = np.arange(9.0).reshape((3, 3))
>>> x2 = np.arange(3.0)
>>> np.divide(x1, x2)
array([[nan, 1. , 1. ],
[inf, 4. , 2.5],
[inf, 7. , 4. ]])

The ``/`` operator can be used as a shorthand for ``np.divide`` on

ndarrays.

>>> x1 = np.arange(9.0).reshape((3, 3))

>>> x2 = 2 * np.ones(3)
>>> x1 / x2
array([[0. , 0.5, 1. ],
[1.5, 2. , 2.5],
[3. , 3.5, 4. ]])

trunc = <ufunc 'trunc'>

trunc(x, /, out=None, *, where=True, casting='same_kind', order='K',
dtype=None, subok=True[, signature, extobj])

Return the truncated value of the input, element-wise.

The truncated value of the scalar `x` is the nearest integer `i` which
is closer to zero than `x` is. In short, the fractional part of the
signed number `x` is discarded.

Parameters
----------
x : array_like
Input data.
out : ndarray, None, or tuple of ndarray and None, optional
A location into which the result is stored. If provided, it must have
a shape that the inputs broadcast to. If not provided or None,
a freshly-allocated array is returned. A tuple (possible only as a
keyword argument) must have length equal to the number of outputs.
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
-------
y : ndarray or scalar
The truncated value of each element in `x`.
This is a scalar if `x` is a scalar.

See Also
--------
ceil, floor, rint, fix

Notes
-----
 .. versionadded:: 1.3.0

Examples
--------
>>> a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0])
>>> np.trunc(a)
array([-1., -1., -0., 0., 1., 1., 2.])

typecodes = {'All': '?bhilqpBHILQPefdgFDGSUVOMm', 'AllFloat': 'efdgFDG...

VERSION
1.26.3

FILE
c:\users\dell\videos\python3\lib\site-packages\numpy\__init__.py